// Generated from java-escape by ANTLR 4.11.1

    package ac.qnlm.antlr;

import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class CPP14Parser extends Parser {
	static { RuntimeMetaData.checkVersion("4.11.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, Noncontenctbrace=7, Alignas=8, 
		Alignof=9, Asm=10, Auto=11, Bool=12, Break=13, Case=14, Catch=15, Char=16, 
		Char16=17, Char32=18, Class=19, Const=20, Constexpr=21, Const_cast=22, 
		Continue=23, Decltype=24, Default=25, Delete=26, Do=27, Double=28, Dynamic_cast=29, 
		Else=30, Enum=31, Explicit=32, Export=33, Extern=34, False=35, Final=36, 
		Float=37, For=38, Friend=39, Goto=40, If=41, Inline=42, Int=43, Long=44, 
		Mutable=45, Namespace=46, New=47, Noexcept=48, Nullptr=49, Operator=50, 
		Override=51, Private=52, Protected=53, Public=54, Register=55, Reinterpret_cast=56, 
		Return=57, Short=58, Signed=59, Sizeof=60, Static=61, Static_assert=62, 
		Static_cast=63, Struct=64, Switch=65, Template=66, This=67, Thread_local=68, 
		Throw=69, True=70, Try=71, Typedef=72, Typeid_=73, Typename_=74, Union=75, 
		Unsigned=76, Using=77, Virtual=78, Void=79, Volatile=80, Wchar=81, While=82, 
		Restrict=83, LeftParen=84, RightParen=85, LeftBracket=86, RightBracket=87, 
		LeftBrace=88, RightBrace=89, Plus=90, Minus=91, Star=92, Div=93, Mod=94, 
		Caret=95, And=96, Or=97, Tilde=98, Not=99, Assign=100, Less=101, Greater=102, 
		PlusAssign=103, MinusAssign=104, StarAssign=105, DivAssign=106, ModAssign=107, 
		XorAssign=108, AndAssign=109, OrAssign=110, Equal=111, NotEqual=112, LessEqual=113, 
		GreaterEqual=114, AndAnd=115, OrOr=116, PlusPlus=117, MinusMinus=118, 
		Comma=119, ArrowStar=120, Arrow=121, Question=122, Colon=123, Doublecolon=124, 
		Semi=125, Dot=126, DotStar=127, Ellipsis=128, Identifier=129, Integerliteral=130, 
		Decimalliteral=131, Octalliteral=132, Hexadecimalliteral=133, Binaryliteral=134, 
		Integersuffix=135, Characterliteral=136, Floatingliteral=137, Stringliteral=138, 
		Userdefinedintegerliteral=139, Userdefinedfloatingliteral=140, Userdefinedstringliteral=141, 
		Userdefinedcharacterliteral=142, MultiLineMacro=143, PragmaDirective=144, 
		IncludeDirective=145, DefineDirective=146, IfDirective=147, ElifDirective=148, 
		IfndefDirective=149, EndifDirective=150, ElseDirective=151, IllegalDirective=152, 
		COMMENT=153, WS=154, LINE_COMMENT=155;
	public static final int
		RULE_translationunit = 0, RULE_primaryexpression = 1, RULE_idexpression = 2, 
		RULE_unqualifiedid = 3, RULE_qualifiedid = 4, RULE_nestednamespecifier = 5, 
		RULE_lambdaexpression = 6, RULE_lambdaintroducer = 7, RULE_lambdacapture = 8, 
		RULE_capturedefault = 9, RULE_capturelist = 10, RULE_capture = 11, RULE_simplecapture = 12, 
		RULE_initcapture = 13, RULE_lambdadeclarator = 14, RULE_postfixexpression = 15, 
		RULE_typeidofexpr = 16, RULE_typeidofthetypeid = 17, RULE_expressionlist = 18, 
		RULE_pseudodestructorname = 19, RULE_unaryexpression = 20, RULE_unaryoperator = 21, 
		RULE_newexpression = 22, RULE_newplacement = 23, RULE_newtypeid = 24, 
		RULE_newdeclarator = 25, RULE_noptrnewdeclarator = 26, RULE_newinitializer = 27, 
		RULE_deleteexpression = 28, RULE_noexceptexpression = 29, RULE_castexpression = 30, 
		RULE_pmexpression = 31, RULE_multiplicativeexpression = 32, RULE_additiveexpression = 33, 
		RULE_shiftexpression = 34, RULE_restrictoperator = 35, RULE_restricttypelist = 36, 
		RULE_restricttype = 37, RULE_shiftoperator = 38, RULE_relationalexpression = 39, 
		RULE_equalityexpression = 40, RULE_andexpression = 41, RULE_exclusiveorexpression = 42, 
		RULE_inclusiveorexpression = 43, RULE_logicalandexpression = 44, RULE_andoperator = 45, 
		RULE_logicalorexpression = 46, RULE_oroperator = 47, RULE_conditionalexpression = 48, 
		RULE_assignmentexpression = 49, RULE_assignmentoperator = 50, RULE_expression = 51, 
		RULE_constantexpression = 52, RULE_statement = 53, RULE_labeledstatement = 54, 
		RULE_expressionstatement = 55, RULE_compoundstatement = 56, RULE_statementseq = 57, 
		RULE_selectionstatement = 58, RULE_condition = 59, RULE_iterationstatement = 60, 
		RULE_forinitstatement = 61, RULE_forrangedeclaration = 62, RULE_forrangeinitializer = 63, 
		RULE_jumpstatement = 64, RULE_declarationstatement = 65, RULE_declarationseq = 66, 
		RULE_declaration = 67, RULE_blockdeclaration = 68, RULE_aliasdeclaration = 69, 
		RULE_simpledeclaration = 70, RULE_static_assertdeclaration = 71, RULE_emptydeclaration = 72, 
		RULE_attributedeclaration = 73, RULE_declspecifier = 74, RULE_declspecifierseq = 75, 
		RULE_storageclassspecifier = 76, RULE_functionspecifier = 77, RULE_typedefname = 78, 
		RULE_structname = 79, RULE_typespecifier = 80, RULE_trailingtypespecifier = 81, 
		RULE_typespecifierseq = 82, RULE_trailingtypespecifierseq = 83, RULE_simpletypespecifier = 84, 
		RULE_thetypename = 85, RULE_decltypespecifier = 86, RULE_elaboratedtypespecifier = 87, 
		RULE_enumname = 88, RULE_enumspecifier = 89, RULE_enumhead = 90, RULE_opaqueenumdeclaration = 91, 
		RULE_enumkey = 92, RULE_enumbase = 93, RULE_enumeratorlist = 94, RULE_enumeratordefinition = 95, 
		RULE_enumerator = 96, RULE_namespacename = 97, RULE_originalnamespacename = 98, 
		RULE_namespacedefinition = 99, RULE_namednamespacedefinition = 100, RULE_originalnamespacedefinition = 101, 
		RULE_extensionnamespacedefinition = 102, RULE_unnamednamespacedefinition = 103, 
		RULE_namespacebody = 104, RULE_namespacealias = 105, RULE_namespacealiasdefinition = 106, 
		RULE_qualifiednamespacespecifier = 107, RULE_usingdeclaration = 108, RULE_usingdirective = 109, 
		RULE_asmdefinition = 110, RULE_linkagespecification = 111, RULE_attributespecifierseq = 112, 
		RULE_attributespecifier = 113, RULE_alignmentspecifier = 114, RULE_attributelist = 115, 
		RULE_attribute = 116, RULE_attributetoken = 117, RULE_attributescopedtoken = 118, 
		RULE_attributenamespace = 119, RULE_attributeargumentclause = 120, RULE_balancedtokenseq = 121, 
		RULE_balancedtoken = 122, RULE_initdeclaratorlist = 123, RULE_initdeclarator = 124, 
		RULE_declarator = 125, RULE_ptrdeclarator = 126, RULE_noptrdeclarator = 127, 
		RULE_parametersandqualifiers = 128, RULE_trailingreturntype = 129, RULE_ptroperator = 130, 
		RULE_cvqualifierseq = 131, RULE_cvqualifier = 132, RULE_refqualifier = 133, 
		RULE_declaratorid = 134, RULE_thetypeid = 135, RULE_abstractdeclarator = 136, 
		RULE_ptrabstractdeclarator = 137, RULE_noptrabstractdeclarator = 138, 
		RULE_abstractpackdeclarator = 139, RULE_noptrabstractpackdeclarator = 140, 
		RULE_parameterdeclarationclause = 141, RULE_parameterdeclarationlist = 142, 
		RULE_parameterdeclaration = 143, RULE_functiondefinition = 144, RULE_functionbody = 145, 
		RULE_initializer = 146, RULE_braceorequalinitializer = 147, RULE_initializerclause = 148, 
		RULE_initializerlist = 149, RULE_bracedinitlist = 150, RULE_classname = 151, 
		RULE_typedefspecifier = 152, RULE_typestructhead = 153, RULE_inherittypedefspecifier = 154, 
		RULE_inheritstructhead = 155, RULE_inheritclassspecifier = 156, RULE_baseclassspecifier = 157, 
		RULE_baseclasshead = 158, RULE_classhead = 159, RULE_classheadname = 160, 
		RULE_classvirtspecifier = 161, RULE_classkey = 162, RULE_typestructkey = 163, 
		RULE_memberspecification = 164, RULE_memberdeclaration = 165, RULE_memberdeclaratorlist = 166, 
		RULE_memberdeclarator = 167, RULE_virtspecifierseq = 168, RULE_virtspecifier = 169, 
		RULE_purespecifier = 170, RULE_baseclause = 171, RULE_basespecifierlist = 172, 
		RULE_basespecifier = 173, RULE_classordecltype = 174, RULE_basetypespecifier = 175, 
		RULE_accessspecifier = 176, RULE_conversionfunctionid = 177, RULE_conversiontypeid = 178, 
		RULE_conversiondeclarator = 179, RULE_ctorinitializer = 180, RULE_meminitializerlist = 181, 
		RULE_meminitializer = 182, RULE_meminitializerid = 183, RULE_operatorfunctionid = 184, 
		RULE_literaloperatorid = 185, RULE_templatedeclaration = 186, RULE_templateparameterlist = 187, 
		RULE_templateparameter = 188, RULE_typeparameter = 189, RULE_simpletemplateid = 190, 
		RULE_templateid = 191, RULE_templatename = 192, RULE_templateargumentlist = 193, 
		RULE_templateargument = 194, RULE_typenamespecifier = 195, RULE_explicitinstantiation = 196, 
		RULE_explicitspecialization = 197, RULE_tryblock = 198, RULE_functiontryblock = 199, 
		RULE_handlerseq = 200, RULE_handler = 201, RULE_exceptiondeclaration = 202, 
		RULE_throwexpression = 203, RULE_exceptionspecification = 204, RULE_dynamicexceptionspecification = 205, 
		RULE_typeidlist = 206, RULE_noexceptspecification = 207, RULE_leftShift = 208, 
		RULE_leftShiftAssign = 209, RULE_rightShift = 210, RULE_rightShiftAssign = 211, 
		RULE_theoperator = 212, RULE_literal = 213, RULE_stringliteralseq = 214, 
		RULE_booleanliteral = 215, RULE_pointerliteral = 216, RULE_userdefinedliteral = 217;
	private static String[] makeRuleNames() {
		return new String[] {
			"translationunit", "primaryexpression", "idexpression", "unqualifiedid", 
			"qualifiedid", "nestednamespecifier", "lambdaexpression", "lambdaintroducer", 
			"lambdacapture", "capturedefault", "capturelist", "capture", "simplecapture", 
			"initcapture", "lambdadeclarator", "postfixexpression", "typeidofexpr", 
			"typeidofthetypeid", "expressionlist", "pseudodestructorname", "unaryexpression", 
			"unaryoperator", "newexpression", "newplacement", "newtypeid", "newdeclarator", 
			"noptrnewdeclarator", "newinitializer", "deleteexpression", "noexceptexpression", 
			"castexpression", "pmexpression", "multiplicativeexpression", "additiveexpression", 
			"shiftexpression", "restrictoperator", "restricttypelist", "restricttype", 
			"shiftoperator", "relationalexpression", "equalityexpression", "andexpression", 
			"exclusiveorexpression", "inclusiveorexpression", "logicalandexpression", 
			"andoperator", "logicalorexpression", "oroperator", "conditionalexpression", 
			"assignmentexpression", "assignmentoperator", "expression", "constantexpression", 
			"statement", "labeledstatement", "expressionstatement", "compoundstatement", 
			"statementseq", "selectionstatement", "condition", "iterationstatement", 
			"forinitstatement", "forrangedeclaration", "forrangeinitializer", "jumpstatement", 
			"declarationstatement", "declarationseq", "declaration", "blockdeclaration", 
			"aliasdeclaration", "simpledeclaration", "static_assertdeclaration", 
			"emptydeclaration", "attributedeclaration", "declspecifier", "declspecifierseq", 
			"storageclassspecifier", "functionspecifier", "typedefname", "structname", 
			"typespecifier", "trailingtypespecifier", "typespecifierseq", "trailingtypespecifierseq", 
			"simpletypespecifier", "thetypename", "decltypespecifier", "elaboratedtypespecifier", 
			"enumname", "enumspecifier", "enumhead", "opaqueenumdeclaration", "enumkey", 
			"enumbase", "enumeratorlist", "enumeratordefinition", "enumerator", "namespacename", 
			"originalnamespacename", "namespacedefinition", "namednamespacedefinition", 
			"originalnamespacedefinition", "extensionnamespacedefinition", "unnamednamespacedefinition", 
			"namespacebody", "namespacealias", "namespacealiasdefinition", "qualifiednamespacespecifier", 
			"usingdeclaration", "usingdirective", "asmdefinition", "linkagespecification", 
			"attributespecifierseq", "attributespecifier", "alignmentspecifier", 
			"attributelist", "attribute", "attributetoken", "attributescopedtoken", 
			"attributenamespace", "attributeargumentclause", "balancedtokenseq", 
			"balancedtoken", "initdeclaratorlist", "initdeclarator", "declarator", 
			"ptrdeclarator", "noptrdeclarator", "parametersandqualifiers", "trailingreturntype", 
			"ptroperator", "cvqualifierseq", "cvqualifier", "refqualifier", "declaratorid", 
			"thetypeid", "abstractdeclarator", "ptrabstractdeclarator", "noptrabstractdeclarator", 
			"abstractpackdeclarator", "noptrabstractpackdeclarator", "parameterdeclarationclause", 
			"parameterdeclarationlist", "parameterdeclaration", "functiondefinition", 
			"functionbody", "initializer", "braceorequalinitializer", "initializerclause", 
			"initializerlist", "bracedinitlist", "classname", "typedefspecifier", 
			"typestructhead", "inherittypedefspecifier", "inheritstructhead", "inheritclassspecifier", 
			"baseclassspecifier", "baseclasshead", "classhead", "classheadname", 
			"classvirtspecifier", "classkey", "typestructkey", "memberspecification", 
			"memberdeclaration", "memberdeclaratorlist", "memberdeclarator", "virtspecifierseq", 
			"virtspecifier", "purespecifier", "baseclause", "basespecifierlist", 
			"basespecifier", "classordecltype", "basetypespecifier", "accessspecifier", 
			"conversionfunctionid", "conversiontypeid", "conversiondeclarator", "ctorinitializer", 
			"meminitializerlist", "meminitializer", "meminitializerid", "operatorfunctionid", 
			"literaloperatorid", "templatedeclaration", "templateparameterlist", 
			"templateparameter", "typeparameter", "simpletemplateid", "templateid", 
			"templatename", "templateargumentlist", "templateargument", "typenamespecifier", 
			"explicitinstantiation", "explicitspecialization", "tryblock", "functiontryblock", 
			"handlerseq", "handler", "exceptiondeclaration", "throwexpression", "exceptionspecification", 
			"dynamicexceptionspecification", "typeidlist", "noexceptspecification", 
			"leftShift", "leftShiftAssign", "rightShift", "rightShiftAssign", "theoperator", 
			"literal", "stringliteralseq", "booleanliteral", "pointerliteral", "userdefinedliteral"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'!'", "'not'", "'and'", "'&&'", "'or'", "'||'", null, "'alignas'", 
			"'alignof'", "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", 
			"'char'", "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", 
			"'const_cast'", "'continue'", "'decltype'", "'default'", "'delete'", 
			"'do'", "'double'", "'dynamic_cast'", "'else'", "'enum'", "'explicit'", 
			"'export'", "'extern'", "'false'", "'final'", "'float'", "'for'", "'friend'", 
			"'goto'", "'if'", "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", 
			"'new'", "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", 
			"'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", 
			"'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", "'static_cast'", 
			"'struct'", "'switch'", "'template'", "'this'", "'thread_local'", "'throw'", 
			"'true'", "'try'", "'typedef'", "'typeid'", "'typename'", "'union'", 
			"'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", "'wchar_t'", 
			"'while'", "'restrict'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'+'", 
			"'-'", "'*'", "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", null, "'='", 
			"'<'", "'>'", "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", "'&='", 
			"'|='", "'=='", "'!='", "'<='", "'>='", null, null, "'++'", "'--'", "','", 
			"'->*'", "'->'", "'?'", "':'", "'::'", "';'", "'.'", "'.*'", "'...'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, null, null, "Noncontenctbrace", "Alignas", 
			"Alignof", "Asm", "Auto", "Bool", "Break", "Case", "Catch", "Char", "Char16", 
			"Char32", "Class", "Const", "Constexpr", "Const_cast", "Continue", "Decltype", 
			"Default", "Delete", "Do", "Double", "Dynamic_cast", "Else", "Enum", 
			"Explicit", "Export", "Extern", "False", "Final", "Float", "For", "Friend", 
			"Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", "New", 
			"Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", 
			"Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", 
			"Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", 
			"Template", "This", "Thread_local", "Throw", "True", "Try", "Typedef", 
			"Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", 
			"Volatile", "Wchar", "While", "Restrict", "LeftParen", "RightParen", 
			"LeftBracket", "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", 
			"Star", "Div", "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", 
			"Less", "Greater", "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", 
			"ModAssign", "XorAssign", "AndAssign", "OrAssign", "Equal", "NotEqual", 
			"LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", "MinusMinus", 
			"Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", "Semi", 
			"Dot", "DotStar", "Ellipsis", "Identifier", "Integerliteral", "Decimalliteral", 
			"Octalliteral", "Hexadecimalliteral", "Binaryliteral", "Integersuffix", 
			"Characterliteral", "Floatingliteral", "Stringliteral", "Userdefinedintegerliteral", 
			"Userdefinedfloatingliteral", "Userdefinedstringliteral", "Userdefinedcharacterliteral", 
			"MultiLineMacro", "PragmaDirective", "IncludeDirective", "DefineDirective", 
			"IfDirective", "ElifDirective", "IfndefDirective", "EndifDirective", 
			"ElseDirective", "IllegalDirective", "COMMENT", "WS", "LINE_COMMENT"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "java-escape"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public CPP14Parser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TranslationunitContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(CPP14Parser.EOF, 0); }
		public DeclarationseqContext declarationseq() {
			return getRuleContext(DeclarationseqContext.class,0);
		}
		public TranslationunitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_translationunit; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTranslationunit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTranslationunit(this);
		}
	}

	public final TranslationunitContext translationunit() throws RecognitionException {
		TranslationunitContext _localctx = new TranslationunitContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_translationunit);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(437);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6253327017007378897L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3674937297293623121L) != 0) {
				{
				setState(436);
				declarationseq(0);
				}
			}

			setState(439);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PrimaryexpressionContext extends ParserRuleContext {
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public TerminalNode This() { return getToken(CPP14Parser.This, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public IdexpressionContext idexpression() {
			return getRuleContext(IdexpressionContext.class,0);
		}
		public LambdaexpressionContext lambdaexpression() {
			return getRuleContext(LambdaexpressionContext.class,0);
		}
		public PrimaryexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primaryexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPrimaryexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPrimaryexpression(this);
		}
	}

	public final PrimaryexpressionContext primaryexpression() throws RecognitionException {
		PrimaryexpressionContext _localctx = new PrimaryexpressionContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_primaryexpression);
		try {
			setState(449);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case False:
			case Nullptr:
			case True:
			case Integerliteral:
			case Characterliteral:
			case Floatingliteral:
			case Stringliteral:
			case Userdefinedintegerliteral:
			case Userdefinedfloatingliteral:
			case Userdefinedstringliteral:
			case Userdefinedcharacterliteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(441);
				literal();
				}
				break;
			case This:
				enterOuterAlt(_localctx, 2);
				{
				setState(442);
				match(This);
				}
				break;
			case LeftParen:
				enterOuterAlt(_localctx, 3);
				{
				setState(443);
				match(LeftParen);
				setState(444);
				expression(0);
				setState(445);
				match(RightParen);
				}
				break;
			case Decltype:
			case Operator:
			case Tilde:
			case Doublecolon:
			case Identifier:
				enterOuterAlt(_localctx, 4);
				{
				setState(447);
				idexpression();
				}
				break;
			case LeftBracket:
				enterOuterAlt(_localctx, 5);
				{
				setState(448);
				lambdaexpression();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IdexpressionContext extends ParserRuleContext {
		public UnqualifiedidContext unqualifiedid() {
			return getRuleContext(UnqualifiedidContext.class,0);
		}
		public QualifiedidContext qualifiedid() {
			return getRuleContext(QualifiedidContext.class,0);
		}
		public IdexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_idexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterIdexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitIdexpression(this);
		}
	}

	public final IdexpressionContext idexpression() throws RecognitionException {
		IdexpressionContext _localctx = new IdexpressionContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_idexpression);
		try {
			setState(453);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(451);
				unqualifiedid();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(452);
				qualifiedid();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UnqualifiedidContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public OperatorfunctionidContext operatorfunctionid() {
			return getRuleContext(OperatorfunctionidContext.class,0);
		}
		public ConversionfunctionidContext conversionfunctionid() {
			return getRuleContext(ConversionfunctionidContext.class,0);
		}
		public LiteraloperatoridContext literaloperatorid() {
			return getRuleContext(LiteraloperatoridContext.class,0);
		}
		public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); }
		public ClassnameContext classname() {
			return getRuleContext(ClassnameContext.class,0);
		}
		public DecltypespecifierContext decltypespecifier() {
			return getRuleContext(DecltypespecifierContext.class,0);
		}
		public TemplateidContext templateid() {
			return getRuleContext(TemplateidContext.class,0);
		}
		public UnqualifiedidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unqualifiedid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnqualifiedid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnqualifiedid(this);
		}
	}

	public final UnqualifiedidContext unqualifiedid() throws RecognitionException {
		UnqualifiedidContext _localctx = new UnqualifiedidContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_unqualifiedid);
		try {
			setState(464);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(455);
				match(Identifier);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(456);
				operatorfunctionid();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(457);
				conversionfunctionid();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(458);
				literaloperatorid();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(459);
				match(Tilde);
				setState(460);
				classname();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(461);
				match(Tilde);
				setState(462);
				decltypespecifier();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(463);
				templateid();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class QualifiedidContext extends ParserRuleContext {
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public UnqualifiedidContext unqualifiedid() {
			return getRuleContext(UnqualifiedidContext.class,0);
		}
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public QualifiedidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_qualifiedid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterQualifiedid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitQualifiedid(this);
		}
	}

	public final QualifiedidContext qualifiedid() throws RecognitionException {
		QualifiedidContext _localctx = new QualifiedidContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_qualifiedid);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(466);
			nestednamespecifier(0);
			setState(468);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Template) {
				{
				setState(467);
				match(Template);
				}
			}

			setState(470);
			unqualifiedid();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NestednamespecifierContext extends ParserRuleContext {
		public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); }
		public ThetypenameContext thetypename() {
			return getRuleContext(ThetypenameContext.class,0);
		}
		public NamespacenameContext namespacename() {
			return getRuleContext(NamespacenameContext.class,0);
		}
		public DecltypespecifierContext decltypespecifier() {
			return getRuleContext(DecltypespecifierContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public NestednamespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nestednamespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNestednamespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNestednamespecifier(this);
		}
	}

	public final NestednamespecifierContext nestednamespecifier() throws RecognitionException {
		return nestednamespecifier(0);
	}

	private NestednamespecifierContext nestednamespecifier(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		NestednamespecifierContext _localctx = new NestednamespecifierContext(_ctx, _parentState);
		NestednamespecifierContext _prevctx = _localctx;
		int _startState = 10;
		enterRecursionRule(_localctx, 10, RULE_nestednamespecifier, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(483);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
			case 1:
				{
				setState(473);
				match(Doublecolon);
				}
				break;
			case 2:
				{
				setState(474);
				thetypename();
				setState(475);
				match(Doublecolon);
				}
				break;
			case 3:
				{
				setState(477);
				namespacename();
				setState(478);
				match(Doublecolon);
				}
				break;
			case 4:
				{
				setState(480);
				decltypespecifier();
				setState(481);
				match(Doublecolon);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(497);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(495);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
					case 1:
						{
						_localctx = new NestednamespecifierContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_nestednamespecifier);
						setState(485);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(486);
						match(Identifier);
						setState(487);
						match(Doublecolon);
						}
						break;
					case 2:
						{
						_localctx = new NestednamespecifierContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_nestednamespecifier);
						setState(488);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(490);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==Template) {
							{
							setState(489);
							match(Template);
							}
						}

						setState(492);
						simpletemplateid();
						setState(493);
						match(Doublecolon);
						}
						break;
					}
					} 
				}
				setState(499);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LambdaexpressionContext extends ParserRuleContext {
		public LambdaintroducerContext lambdaintroducer() {
			return getRuleContext(LambdaintroducerContext.class,0);
		}
		public CompoundstatementContext compoundstatement() {
			return getRuleContext(CompoundstatementContext.class,0);
		}
		public LambdadeclaratorContext lambdadeclarator() {
			return getRuleContext(LambdadeclaratorContext.class,0);
		}
		public LambdaexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambdaexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdaexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdaexpression(this);
		}
	}

	public final LambdaexpressionContext lambdaexpression() throws RecognitionException {
		LambdaexpressionContext _localctx = new LambdaexpressionContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_lambdaexpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(500);
			lambdaintroducer();
			setState(502);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LeftParen) {
				{
				setState(501);
				lambdadeclarator();
				}
			}

			setState(504);
			compoundstatement();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LambdaintroducerContext extends ParserRuleContext {
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public LambdacaptureContext lambdacapture() {
			return getRuleContext(LambdacaptureContext.class,0);
		}
		public LambdaintroducerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambdaintroducer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdaintroducer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdaintroducer(this);
		}
	}

	public final LambdaintroducerContext lambdaintroducer() throws RecognitionException {
		LambdaintroducerContext _localctx = new LambdaintroducerContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_lambdaintroducer);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(506);
			match(LeftBracket);
			setState(508);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 4611686027554193409L) != 0) {
				{
				setState(507);
				lambdacapture();
				}
			}

			setState(510);
			match(RightBracket);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LambdacaptureContext extends ParserRuleContext {
		public CapturedefaultContext capturedefault() {
			return getRuleContext(CapturedefaultContext.class,0);
		}
		public CapturelistContext capturelist() {
			return getRuleContext(CapturelistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public LambdacaptureContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambdacapture; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdacapture(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdacapture(this);
		}
	}

	public final LambdacaptureContext lambdacapture() throws RecognitionException {
		LambdacaptureContext _localctx = new LambdacaptureContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_lambdacapture);
		try {
			setState(518);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(512);
				capturedefault();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(513);
				capturelist(0);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(514);
				capturedefault();
				setState(515);
				match(Comma);
				setState(516);
				capturelist(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CapturedefaultContext extends ParserRuleContext {
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public CapturedefaultContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_capturedefault; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCapturedefault(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCapturedefault(this);
		}
	}

	public final CapturedefaultContext capturedefault() throws RecognitionException {
		CapturedefaultContext _localctx = new CapturedefaultContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_capturedefault);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(520);
			_la = _input.LA(1);
			if ( !(_la==And || _la==Assign) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CapturelistContext extends ParserRuleContext {
		public CaptureContext capture() {
			return getRuleContext(CaptureContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public CapturelistContext capturelist() {
			return getRuleContext(CapturelistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public CapturelistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_capturelist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCapturelist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCapturelist(this);
		}
	}

	public final CapturelistContext capturelist() throws RecognitionException {
		return capturelist(0);
	}

	private CapturelistContext capturelist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		CapturelistContext _localctx = new CapturelistContext(_ctx, _parentState);
		CapturelistContext _prevctx = _localctx;
		int _startState = 20;
		enterRecursionRule(_localctx, 20, RULE_capturelist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(523);
			capture();
			setState(525);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				{
				setState(524);
				match(Ellipsis);
				}
				break;
			}
			}
			_ctx.stop = _input.LT(-1);
			setState(535);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new CapturelistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_capturelist);
					setState(527);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(528);
					match(Comma);
					setState(529);
					capture();
					setState(531);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
					case 1:
						{
						setState(530);
						match(Ellipsis);
						}
						break;
					}
					}
					} 
				}
				setState(537);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CaptureContext extends ParserRuleContext {
		public SimplecaptureContext simplecapture() {
			return getRuleContext(SimplecaptureContext.class,0);
		}
		public InitcaptureContext initcapture() {
			return getRuleContext(InitcaptureContext.class,0);
		}
		public CaptureContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_capture; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCapture(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCapture(this);
		}
	}

	public final CaptureContext capture() throws RecognitionException {
		CaptureContext _localctx = new CaptureContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_capture);
		try {
			setState(540);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(538);
				simplecapture();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(539);
				initcapture();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SimplecaptureContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public TerminalNode This() { return getToken(CPP14Parser.This, 0); }
		public SimplecaptureContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_simplecapture; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimplecapture(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimplecapture(this);
		}
	}

	public final SimplecaptureContext simplecapture() throws RecognitionException {
		SimplecaptureContext _localctx = new SimplecaptureContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_simplecapture);
		try {
			setState(546);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(542);
				match(Identifier);
				}
				break;
			case And:
				enterOuterAlt(_localctx, 2);
				{
				setState(543);
				match(And);
				setState(544);
				match(Identifier);
				}
				break;
			case This:
				enterOuterAlt(_localctx, 3);
				{
				setState(545);
				match(This);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InitcaptureContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public InitializerContext initializer() {
			return getRuleContext(InitializerContext.class,0);
		}
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public InitcaptureContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initcapture; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitcapture(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitcapture(this);
		}
	}

	public final InitcaptureContext initcapture() throws RecognitionException {
		InitcaptureContext _localctx = new InitcaptureContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_initcapture);
		try {
			setState(553);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(548);
				match(Identifier);
				setState(549);
				initializer();
				}
				break;
			case And:
				enterOuterAlt(_localctx, 2);
				{
				setState(550);
				match(And);
				setState(551);
				match(Identifier);
				setState(552);
				initializer();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LambdadeclaratorContext extends ParserRuleContext {
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ParameterdeclarationclauseContext parameterdeclarationclause() {
			return getRuleContext(ParameterdeclarationclauseContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TerminalNode Mutable() { return getToken(CPP14Parser.Mutable, 0); }
		public ExceptionspecificationContext exceptionspecification() {
			return getRuleContext(ExceptionspecificationContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TrailingreturntypeContext trailingreturntype() {
			return getRuleContext(TrailingreturntypeContext.class,0);
		}
		public LambdadeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambdadeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdadeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdadeclarator(this);
		}
	}

	public final LambdadeclaratorContext lambdadeclarator() throws RecognitionException {
		LambdadeclaratorContext _localctx = new LambdadeclaratorContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_lambdadeclarator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(555);
			match(LeftParen);
			setState(556);
			parameterdeclarationclause();
			setState(557);
			match(RightParen);
			setState(559);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Mutable) {
				{
				setState(558);
				match(Mutable);
				}
			}

			setState(562);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Noexcept || _la==Throw) {
				{
				setState(561);
				exceptionspecification();
				}
			}

			setState(565);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Alignas || _la==LeftBracket) {
				{
				setState(564);
				attributespecifierseq(0);
				}
			}

			setState(568);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Arrow) {
				{
				setState(567);
				trailingreturntype();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PostfixexpressionContext extends ParserRuleContext {
		public PrimaryexpressionContext primaryexpression() {
			return getRuleContext(PrimaryexpressionContext.class,0);
		}
		public SimpletypespecifierContext simpletypespecifier() {
			return getRuleContext(SimpletypespecifierContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public ExpressionlistContext expressionlist() {
			return getRuleContext(ExpressionlistContext.class,0);
		}
		public TypenamespecifierContext typenamespecifier() {
			return getRuleContext(TypenamespecifierContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public TerminalNode Dynamic_cast() { return getToken(CPP14Parser.Dynamic_cast, 0); }
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode Static_cast() { return getToken(CPP14Parser.Static_cast, 0); }
		public TerminalNode Reinterpret_cast() { return getToken(CPP14Parser.Reinterpret_cast, 0); }
		public TerminalNode Const_cast() { return getToken(CPP14Parser.Const_cast, 0); }
		public TypeidofthetypeidContext typeidofthetypeid() {
			return getRuleContext(TypeidofthetypeidContext.class,0);
		}
		public PostfixexpressionContext postfixexpression() {
			return getRuleContext(PostfixexpressionContext.class,0);
		}
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public TerminalNode Dot() { return getToken(CPP14Parser.Dot, 0); }
		public IdexpressionContext idexpression() {
			return getRuleContext(IdexpressionContext.class,0);
		}
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public TerminalNode Arrow() { return getToken(CPP14Parser.Arrow, 0); }
		public PseudodestructornameContext pseudodestructorname() {
			return getRuleContext(PseudodestructornameContext.class,0);
		}
		public TerminalNode PlusPlus() { return getToken(CPP14Parser.PlusPlus, 0); }
		public TerminalNode MinusMinus() { return getToken(CPP14Parser.MinusMinus, 0); }
		public PostfixexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_postfixexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPostfixexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPostfixexpression(this);
		}
	}

	public final PostfixexpressionContext postfixexpression() throws RecognitionException {
		return postfixexpression(0);
	}

	private PostfixexpressionContext postfixexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		PostfixexpressionContext _localctx = new PostfixexpressionContext(_ctx, _parentState);
		PostfixexpressionContext _prevctx = _localctx;
		int _startState = 30;
		enterRecursionRule(_localctx, 30, RULE_postfixexpression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(635);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
			case 1:
				{
				setState(571);
				primaryexpression();
				}
				break;
			case 2:
				{
				setState(572);
				simpletypespecifier();
				setState(573);
				match(LeftParen);
				setState(575);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132927793001L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(574);
					expressionlist();
					}
				}

				setState(577);
				match(RightParen);
				}
				break;
			case 3:
				{
				setState(579);
				typenamespecifier();
				setState(580);
				match(LeftParen);
				setState(582);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132927793001L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(581);
					expressionlist();
					}
				}

				setState(584);
				match(RightParen);
				}
				break;
			case 4:
				{
				setState(586);
				simpletypespecifier();
				setState(588);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
				case 1:
					{
					setState(587);
					bracedinitlist();
					}
					break;
				}
				}
				break;
			case 5:
				{
				setState(590);
				typenamespecifier();
				setState(591);
				bracedinitlist();
				}
				break;
			case 6:
				{
				setState(593);
				match(Dynamic_cast);
				setState(594);
				match(Less);
				setState(595);
				thetypeid();
				setState(596);
				match(Greater);
				setState(597);
				match(LeftParen);
				setState(598);
				expression(0);
				setState(599);
				match(RightParen);
				}
				break;
			case 7:
				{
				setState(601);
				match(Static_cast);
				setState(602);
				match(Less);
				setState(603);
				thetypeid();
				setState(604);
				match(Greater);
				setState(605);
				match(LeftParen);
				setState(606);
				expression(0);
				setState(607);
				match(RightParen);
				}
				break;
			case 8:
				{
				setState(609);
				match(Reinterpret_cast);
				setState(610);
				match(Less);
				setState(611);
				thetypeid();
				setState(612);
				match(Greater);
				setState(613);
				match(LeftParen);
				setState(614);
				expression(0);
				setState(615);
				match(RightParen);
				}
				break;
			case 9:
				{
				setState(617);
				match(Const_cast);
				setState(618);
				match(Less);
				setState(619);
				thetypeid();
				setState(620);
				match(Greater);
				setState(621);
				match(LeftParen);
				setState(622);
				expression(0);
				setState(623);
				match(RightParen);
				}
				break;
			case 10:
				{
				setState(625);
				typeidofthetypeid();
				setState(626);
				match(LeftParen);
				setState(627);
				expression(0);
				setState(628);
				match(RightParen);
				}
				break;
			case 11:
				{
				setState(630);
				typeidofthetypeid();
				setState(631);
				match(LeftParen);
				setState(632);
				thetypeid();
				setState(633);
				match(RightParen);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(677);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(675);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
					case 1:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(637);
						if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
						setState(638);
						match(LeftBracket);
						setState(639);
						expression(0);
						setState(640);
						match(RightBracket);
						}
						break;
					case 2:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(642);
						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
						setState(643);
						match(LeftBracket);
						setState(644);
						bracedinitlist();
						setState(645);
						match(RightBracket);
						}
						break;
					case 3:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(647);
						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
						setState(648);
						match(LeftParen);
						setState(650);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132927793001L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
							{
							setState(649);
							expressionlist();
							}
						}

						setState(652);
						match(RightParen);
						}
						break;
					case 4:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(653);
						if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
						setState(654);
						match(Dot);
						setState(656);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==Template) {
							{
							setState(655);
							match(Template);
							}
						}

						setState(658);
						idexpression();
						}
						break;
					case 5:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(659);
						if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
						setState(660);
						match(Arrow);
						setState(662);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==Template) {
							{
							setState(661);
							match(Template);
							}
						}

						setState(664);
						idexpression();
						}
						break;
					case 6:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(665);
						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
						setState(666);
						match(Dot);
						setState(667);
						pseudodestructorname();
						}
						break;
					case 7:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(668);
						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
						setState(669);
						match(Arrow);
						setState(670);
						pseudodestructorname();
						}
						break;
					case 8:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(671);
						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
						setState(672);
						match(PlusPlus);
						}
						break;
					case 9:
						{
						_localctx = new PostfixexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
						setState(673);
						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
						setState(674);
						match(MinusMinus);
						}
						break;
					}
					} 
				}
				setState(679);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeidofexprContext extends ParserRuleContext {
		public TerminalNode Typeid_() { return getToken(CPP14Parser.Typeid_, 0); }
		public TypeidofexprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeidofexpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypeidofexpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypeidofexpr(this);
		}
	}

	public final TypeidofexprContext typeidofexpr() throws RecognitionException {
		TypeidofexprContext _localctx = new TypeidofexprContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_typeidofexpr);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(680);
			match(Typeid_);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeidofthetypeidContext extends ParserRuleContext {
		public TerminalNode Typeid_() { return getToken(CPP14Parser.Typeid_, 0); }
		public TypeidofthetypeidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeidofthetypeid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypeidofthetypeid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypeidofthetypeid(this);
		}
	}

	public final TypeidofthetypeidContext typeidofthetypeid() throws RecognitionException {
		TypeidofthetypeidContext _localctx = new TypeidofthetypeidContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_typeidofthetypeid);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(682);
			match(Typeid_);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExpressionlistContext extends ParserRuleContext {
		public InitializerlistContext initializerlist() {
			return getRuleContext(InitializerlistContext.class,0);
		}
		public ExpressionlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExpressionlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExpressionlist(this);
		}
	}

	public final ExpressionlistContext expressionlist() throws RecognitionException {
		ExpressionlistContext _localctx = new ExpressionlistContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_expressionlist);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(684);
			initializerlist(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PseudodestructornameContext extends ParserRuleContext {
		public List<ThetypenameContext> thetypename() {
			return getRuleContexts(ThetypenameContext.class);
		}
		public ThetypenameContext thetypename(int i) {
			return getRuleContext(ThetypenameContext.class,i);
		}
		public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); }
		public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); }
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public DecltypespecifierContext decltypespecifier() {
			return getRuleContext(DecltypespecifierContext.class,0);
		}
		public PseudodestructornameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pseudodestructorname; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPseudodestructorname(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPseudodestructorname(this);
		}
	}

	public final PseudodestructornameContext pseudodestructorname() throws RecognitionException {
		PseudodestructornameContext _localctx = new PseudodestructornameContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_pseudodestructorname);
		int _la;
		try {
			setState(708);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(687);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
				case 1:
					{
					setState(686);
					nestednamespecifier(0);
					}
					break;
				}
				setState(689);
				thetypename();
				setState(690);
				match(Doublecolon);
				setState(691);
				match(Tilde);
				setState(692);
				thetypename();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(694);
				nestednamespecifier(0);
				setState(695);
				match(Template);
				setState(696);
				simpletemplateid();
				setState(697);
				match(Doublecolon);
				setState(698);
				match(Tilde);
				setState(699);
				thetypename();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(702);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Decltype || _la==Doublecolon || _la==Identifier) {
					{
					setState(701);
					nestednamespecifier(0);
					}
				}

				setState(704);
				match(Tilde);
				setState(705);
				thetypename();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(706);
				match(Tilde);
				setState(707);
				decltypespecifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UnaryexpressionContext extends ParserRuleContext {
		public PostfixexpressionContext postfixexpression() {
			return getRuleContext(PostfixexpressionContext.class,0);
		}
		public TerminalNode PlusPlus() { return getToken(CPP14Parser.PlusPlus, 0); }
		public CastexpressionContext castexpression() {
			return getRuleContext(CastexpressionContext.class,0);
		}
		public TerminalNode MinusMinus() { return getToken(CPP14Parser.MinusMinus, 0); }
		public UnaryoperatorContext unaryoperator() {
			return getRuleContext(UnaryoperatorContext.class,0);
		}
		public TerminalNode Sizeof() { return getToken(CPP14Parser.Sizeof, 0); }
		public UnaryexpressionContext unaryexpression() {
			return getRuleContext(UnaryexpressionContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode Alignof() { return getToken(CPP14Parser.Alignof, 0); }
		public NoexceptexpressionContext noexceptexpression() {
			return getRuleContext(NoexceptexpressionContext.class,0);
		}
		public NewexpressionContext newexpression() {
			return getRuleContext(NewexpressionContext.class,0);
		}
		public DeleteexpressionContext deleteexpression() {
			return getRuleContext(DeleteexpressionContext.class,0);
		}
		public UnaryexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unaryexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnaryexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnaryexpression(this);
		}
	}

	public final UnaryexpressionContext unaryexpression() throws RecognitionException {
		UnaryexpressionContext _localctx = new UnaryexpressionContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_unaryexpression);
		try {
			setState(738);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(710);
				postfixexpression(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(711);
				match(PlusPlus);
				setState(712);
				castexpression();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(713);
				match(MinusMinus);
				setState(714);
				castexpression();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(715);
				unaryoperator();
				setState(716);
				castexpression();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(718);
				match(Sizeof);
				setState(719);
				unaryexpression();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(720);
				match(Sizeof);
				setState(721);
				match(LeftParen);
				setState(722);
				thetypeid();
				setState(723);
				match(RightParen);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(725);
				match(Sizeof);
				setState(726);
				match(Ellipsis);
				setState(727);
				match(LeftParen);
				setState(728);
				match(Identifier);
				setState(729);
				match(RightParen);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(730);
				match(Alignof);
				setState(731);
				match(LeftParen);
				setState(732);
				thetypeid();
				setState(733);
				match(RightParen);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(735);
				noexceptexpression();
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(736);
				newexpression();
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(737);
				deleteexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UnaryoperatorContext extends ParserRuleContext {
		public TerminalNode Or() { return getToken(CPP14Parser.Or, 0); }
		public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); }
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public TerminalNode Plus() { return getToken(CPP14Parser.Plus, 0); }
		public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); }
		public TerminalNode Minus() { return getToken(CPP14Parser.Minus, 0); }
		public UnaryoperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unaryoperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnaryoperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnaryoperator(this);
		}
	}

	public final UnaryoperatorContext unaryoperator() throws RecognitionException {
		UnaryoperatorContext _localctx = new UnaryoperatorContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_unaryoperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(740);
			_la = _input.LA(1);
			if ( !(_la==T__0 || _la==T__1 || (((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & 455L) != 0) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NewexpressionContext extends ParserRuleContext {
		public TerminalNode New() { return getToken(CPP14Parser.New, 0); }
		public NewtypeidContext newtypeid() {
			return getRuleContext(NewtypeidContext.class,0);
		}
		public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); }
		public NewplacementContext newplacement() {
			return getRuleContext(NewplacementContext.class,0);
		}
		public NewinitializerContext newinitializer() {
			return getRuleContext(NewinitializerContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public NewexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_newexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewexpression(this);
		}
	}

	public final NewexpressionContext newexpression() throws RecognitionException {
		NewexpressionContext _localctx = new NewexpressionContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_newexpression);
		int _la;
		try {
			setState(766);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(743);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Doublecolon) {
					{
					setState(742);
					match(Doublecolon);
					}
				}

				setState(745);
				match(New);
				setState(747);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LeftParen) {
					{
					setState(746);
					newplacement();
					}
				}

				setState(749);
				newtypeid();
				setState(751);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
				case 1:
					{
					setState(750);
					newinitializer();
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(754);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Doublecolon) {
					{
					setState(753);
					match(Doublecolon);
					}
				}

				setState(756);
				match(New);
				setState(758);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
				case 1:
					{
					setState(757);
					newplacement();
					}
					break;
				}
				setState(760);
				match(LeftParen);
				setState(761);
				thetypeid();
				setState(762);
				match(RightParen);
				setState(764);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
				case 1:
					{
					setState(763);
					newinitializer();
					}
					break;
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NewplacementContext extends ParserRuleContext {
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ExpressionlistContext expressionlist() {
			return getRuleContext(ExpressionlistContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public NewplacementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_newplacement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewplacement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewplacement(this);
		}
	}

	public final NewplacementContext newplacement() throws RecognitionException {
		NewplacementContext _localctx = new NewplacementContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_newplacement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(768);
			match(LeftParen);
			setState(769);
			expressionlist();
			setState(770);
			match(RightParen);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NewtypeidContext extends ParserRuleContext {
		public TypespecifierseqContext typespecifierseq() {
			return getRuleContext(TypespecifierseqContext.class,0);
		}
		public NewdeclaratorContext newdeclarator() {
			return getRuleContext(NewdeclaratorContext.class,0);
		}
		public NewtypeidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_newtypeid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewtypeid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewtypeid(this);
		}
	}

	public final NewtypeidContext newtypeid() throws RecognitionException {
		NewtypeidContext _localctx = new NewtypeidContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_newtypeid);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(772);
			typespecifierseq();
			setState(774);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
			case 1:
				{
				setState(773);
				newdeclarator();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NewdeclaratorContext extends ParserRuleContext {
		public PtroperatorContext ptroperator() {
			return getRuleContext(PtroperatorContext.class,0);
		}
		public NewdeclaratorContext newdeclarator() {
			return getRuleContext(NewdeclaratorContext.class,0);
		}
		public NoptrnewdeclaratorContext noptrnewdeclarator() {
			return getRuleContext(NoptrnewdeclaratorContext.class,0);
		}
		public NewdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_newdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewdeclarator(this);
		}
	}

	public final NewdeclaratorContext newdeclarator() throws RecognitionException {
		NewdeclaratorContext _localctx = new NewdeclaratorContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_newdeclarator);
		try {
			setState(781);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__3:
			case Decltype:
			case Star:
			case And:
			case Doublecolon:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(776);
				ptroperator();
				setState(778);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
				case 1:
					{
					setState(777);
					newdeclarator();
					}
					break;
				}
				}
				break;
			case LeftBracket:
				enterOuterAlt(_localctx, 2);
				{
				setState(780);
				noptrnewdeclarator(0);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NoptrnewdeclaratorContext extends ParserRuleContext {
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public NoptrnewdeclaratorContext noptrnewdeclarator() {
			return getRuleContext(NoptrnewdeclaratorContext.class,0);
		}
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public NoptrnewdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_noptrnewdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrnewdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrnewdeclarator(this);
		}
	}

	public final NoptrnewdeclaratorContext noptrnewdeclarator() throws RecognitionException {
		return noptrnewdeclarator(0);
	}

	private NoptrnewdeclaratorContext noptrnewdeclarator(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		NoptrnewdeclaratorContext _localctx = new NoptrnewdeclaratorContext(_ctx, _parentState);
		NoptrnewdeclaratorContext _prevctx = _localctx;
		int _startState = 52;
		enterRecursionRule(_localctx, 52, RULE_noptrnewdeclarator, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(784);
			match(LeftBracket);
			setState(785);
			expression(0);
			setState(786);
			match(RightBracket);
			setState(788);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
			case 1:
				{
				setState(787);
				attributespecifierseq(0);
				}
				break;
			}
			}
			_ctx.stop = _input.LT(-1);
			setState(799);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,47,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new NoptrnewdeclaratorContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_noptrnewdeclarator);
					setState(790);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(791);
					match(LeftBracket);
					setState(792);
					constantexpression();
					setState(793);
					match(RightBracket);
					setState(795);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
					case 1:
						{
						setState(794);
						attributespecifierseq(0);
						}
						break;
					}
					}
					} 
				}
				setState(801);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,47,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NewinitializerContext extends ParserRuleContext {
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public ExpressionlistContext expressionlist() {
			return getRuleContext(ExpressionlistContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public NewinitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_newinitializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewinitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewinitializer(this);
		}
	}

	public final NewinitializerContext newinitializer() throws RecognitionException {
		NewinitializerContext _localctx = new NewinitializerContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_newinitializer);
		int _la;
		try {
			setState(808);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LeftParen:
				enterOuterAlt(_localctx, 1);
				{
				setState(802);
				match(LeftParen);
				setState(804);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132927793001L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(803);
					expressionlist();
					}
				}

				setState(806);
				match(RightParen);
				}
				break;
			case LeftBrace:
				enterOuterAlt(_localctx, 2);
				{
				setState(807);
				bracedinitlist();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeleteexpressionContext extends ParserRuleContext {
		public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); }
		public CastexpressionContext castexpression() {
			return getRuleContext(CastexpressionContext.class,0);
		}
		public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); }
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public DeleteexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deleteexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeleteexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeleteexpression(this);
		}
	}

	public final DeleteexpressionContext deleteexpression() throws RecognitionException {
		DeleteexpressionContext _localctx = new DeleteexpressionContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_deleteexpression);
		int _la;
		try {
			setState(822);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(811);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Doublecolon) {
					{
					setState(810);
					match(Doublecolon);
					}
				}

				setState(813);
				match(Delete);
				setState(814);
				castexpression();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(816);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Doublecolon) {
					{
					setState(815);
					match(Doublecolon);
					}
				}

				setState(818);
				match(Delete);
				setState(819);
				match(LeftBracket);
				setState(820);
				match(RightBracket);
				setState(821);
				castexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NoexceptexpressionContext extends ParserRuleContext {
		public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public NoexceptexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_noexceptexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoexceptexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoexceptexpression(this);
		}
	}

	public final NoexceptexpressionContext noexceptexpression() throws RecognitionException {
		NoexceptexpressionContext _localctx = new NoexceptexpressionContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_noexceptexpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(824);
			match(Noexcept);
			setState(825);
			match(LeftParen);
			setState(826);
			expression(0);
			setState(827);
			match(RightParen);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CastexpressionContext extends ParserRuleContext {
		public UnaryexpressionContext unaryexpression() {
			return getRuleContext(UnaryexpressionContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public CastexpressionContext castexpression() {
			return getRuleContext(CastexpressionContext.class,0);
		}
		public CastexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_castexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCastexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCastexpression(this);
		}
	}

	public final CastexpressionContext castexpression() throws RecognitionException {
		CastexpressionContext _localctx = new CastexpressionContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_castexpression);
		try {
			setState(835);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(829);
				unaryexpression();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(830);
				match(LeftParen);
				setState(831);
				thetypeid();
				setState(832);
				match(RightParen);
				setState(833);
				castexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PmexpressionContext extends ParserRuleContext {
		public CastexpressionContext castexpression() {
			return getRuleContext(CastexpressionContext.class,0);
		}
		public PmexpressionContext pmexpression() {
			return getRuleContext(PmexpressionContext.class,0);
		}
		public TerminalNode DotStar() { return getToken(CPP14Parser.DotStar, 0); }
		public TerminalNode ArrowStar() { return getToken(CPP14Parser.ArrowStar, 0); }
		public PmexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pmexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPmexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPmexpression(this);
		}
	}

	public final PmexpressionContext pmexpression() throws RecognitionException {
		return pmexpression(0);
	}

	private PmexpressionContext pmexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		PmexpressionContext _localctx = new PmexpressionContext(_ctx, _parentState);
		PmexpressionContext _prevctx = _localctx;
		int _startState = 62;
		enterRecursionRule(_localctx, 62, RULE_pmexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(838);
			castexpression();
			}
			_ctx.stop = _input.LT(-1);
			setState(848);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(846);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
					case 1:
						{
						_localctx = new PmexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_pmexpression);
						setState(840);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(841);
						match(DotStar);
						setState(842);
						castexpression();
						}
						break;
					case 2:
						{
						_localctx = new PmexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_pmexpression);
						setState(843);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(844);
						match(ArrowStar);
						setState(845);
						castexpression();
						}
						break;
					}
					} 
				}
				setState(850);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MultiplicativeexpressionContext extends ParserRuleContext {
		public PmexpressionContext pmexpression() {
			return getRuleContext(PmexpressionContext.class,0);
		}
		public MultiplicativeexpressionContext multiplicativeexpression() {
			return getRuleContext(MultiplicativeexpressionContext.class,0);
		}
		public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); }
		public RestrictoperatorContext restrictoperator() {
			return getRuleContext(RestrictoperatorContext.class,0);
		}
		public TerminalNode Div() { return getToken(CPP14Parser.Div, 0); }
		public TerminalNode Mod() { return getToken(CPP14Parser.Mod, 0); }
		public MultiplicativeexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_multiplicativeexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMultiplicativeexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMultiplicativeexpression(this);
		}
	}

	public final MultiplicativeexpressionContext multiplicativeexpression() throws RecognitionException {
		return multiplicativeexpression(0);
	}

	private MultiplicativeexpressionContext multiplicativeexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		MultiplicativeexpressionContext _localctx = new MultiplicativeexpressionContext(_ctx, _parentState);
		MultiplicativeexpressionContext _prevctx = _localctx;
		int _startState = 64;
		enterRecursionRule(_localctx, 64, RULE_multiplicativeexpression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(852);
			pmexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(871);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(869);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
					case 1:
						{
						_localctx = new MultiplicativeexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeexpression);
						setState(854);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(855);
						match(Star);
						setState(856);
						pmexpression(0);
						}
						break;
					case 2:
						{
						_localctx = new MultiplicativeexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeexpression);
						setState(857);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(858);
						match(Star);
						setState(860);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==Restrict) {
							{
							setState(859);
							restrictoperator();
							}
						}

						setState(862);
						pmexpression(0);
						}
						break;
					case 3:
						{
						_localctx = new MultiplicativeexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeexpression);
						setState(863);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(864);
						match(Div);
						setState(865);
						pmexpression(0);
						}
						break;
					case 4:
						{
						_localctx = new MultiplicativeexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeexpression);
						setState(866);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(867);
						match(Mod);
						setState(868);
						pmexpression(0);
						}
						break;
					}
					} 
				}
				setState(873);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AdditiveexpressionContext extends ParserRuleContext {
		public MultiplicativeexpressionContext multiplicativeexpression() {
			return getRuleContext(MultiplicativeexpressionContext.class,0);
		}
		public AdditiveexpressionContext additiveexpression() {
			return getRuleContext(AdditiveexpressionContext.class,0);
		}
		public TerminalNode Plus() { return getToken(CPP14Parser.Plus, 0); }
		public TerminalNode Minus() { return getToken(CPP14Parser.Minus, 0); }
		public AdditiveexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_additiveexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAdditiveexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAdditiveexpression(this);
		}
	}

	public final AdditiveexpressionContext additiveexpression() throws RecognitionException {
		return additiveexpression(0);
	}

	private AdditiveexpressionContext additiveexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		AdditiveexpressionContext _localctx = new AdditiveexpressionContext(_ctx, _parentState);
		AdditiveexpressionContext _prevctx = _localctx;
		int _startState = 66;
		enterRecursionRule(_localctx, 66, RULE_additiveexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(875);
			multiplicativeexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(885);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(883);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
					case 1:
						{
						_localctx = new AdditiveexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_additiveexpression);
						setState(877);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(878);
						match(Plus);
						setState(879);
						multiplicativeexpression(0);
						}
						break;
					case 2:
						{
						_localctx = new AdditiveexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_additiveexpression);
						setState(880);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(881);
						match(Minus);
						setState(882);
						multiplicativeexpression(0);
						}
						break;
					}
					} 
				}
				setState(887);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ShiftexpressionContext extends ParserRuleContext {
		public AdditiveexpressionContext additiveexpression() {
			return getRuleContext(AdditiveexpressionContext.class,0);
		}
		public ShiftexpressionContext shiftexpression() {
			return getRuleContext(ShiftexpressionContext.class,0);
		}
		public ShiftoperatorContext shiftoperator() {
			return getRuleContext(ShiftoperatorContext.class,0);
		}
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public ShiftexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shiftexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterShiftexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitShiftexpression(this);
		}
	}

	public final ShiftexpressionContext shiftexpression() throws RecognitionException {
		return shiftexpression(0);
	}

	private ShiftexpressionContext shiftexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ShiftexpressionContext _localctx = new ShiftexpressionContext(_ctx, _parentState);
		ShiftexpressionContext _prevctx = _localctx;
		int _startState = 68;
		enterRecursionRule(_localctx, 68, RULE_shiftexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(889);
			additiveexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(900);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(898);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
					case 1:
						{
						_localctx = new ShiftexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_shiftexpression);
						setState(891);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(892);
						shiftoperator();
						setState(893);
						additiveexpression(0);
						}
						break;
					case 2:
						{
						_localctx = new ShiftexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_shiftexpression);
						setState(895);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(896);
						match(Less);
						setState(897);
						additiveexpression(0);
						}
						break;
					}
					} 
				}
				setState(902);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RestrictoperatorContext extends ParserRuleContext {
		public TerminalNode Restrict() { return getToken(CPP14Parser.Restrict, 0); }
		public RestrictoperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_restrictoperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRestrictoperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRestrictoperator(this);
		}
	}

	public final RestrictoperatorContext restrictoperator() throws RecognitionException {
		RestrictoperatorContext _localctx = new RestrictoperatorContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_restrictoperator);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(903);
			match(Restrict);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RestricttypelistContext extends ParserRuleContext {
		public RestricttypeContext restricttype() {
			return getRuleContext(RestricttypeContext.class,0);
		}
		public RestricttypelistContext restricttypelist() {
			return getRuleContext(RestricttypelistContext.class,0);
		}
		public RestricttypelistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_restricttypelist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRestricttypelist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRestricttypelist(this);
		}
	}

	public final RestricttypelistContext restricttypelist() throws RecognitionException {
		return restricttypelist(0);
	}

	private RestricttypelistContext restricttypelist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		RestricttypelistContext _localctx = new RestricttypelistContext(_ctx, _parentState);
		RestricttypelistContext _prevctx = _localctx;
		int _startState = 72;
		enterRecursionRule(_localctx, 72, RULE_restricttypelist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(906);
			restricttype();
			}
			_ctx.stop = _input.LT(-1);
			setState(912);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new RestricttypelistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_restricttypelist);
					setState(908);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(909);
					restricttype();
					}
					} 
				}
				setState(914);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RestricttypeContext extends ParserRuleContext {
		public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); }
		public TerminalNode Restrict() { return getToken(CPP14Parser.Restrict, 0); }
		public TerminalNode Const() { return getToken(CPP14Parser.Const, 0); }
		public RestricttypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_restricttype; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRestricttype(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRestricttype(this);
		}
	}

	public final RestricttypeContext restricttype() throws RecognitionException {
		RestricttypeContext _localctx = new RestricttypeContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_restricttype);
		try {
			setState(920);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(915);
				match(Star);
				setState(916);
				match(Restrict);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(917);
				match(Star);
				setState(918);
				match(Const);
				setState(919);
				match(Restrict);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ShiftoperatorContext extends ParserRuleContext {
		public RightShiftContext rightShift() {
			return getRuleContext(RightShiftContext.class,0);
		}
		public LeftShiftContext leftShift() {
			return getRuleContext(LeftShiftContext.class,0);
		}
		public ShiftoperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shiftoperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterShiftoperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitShiftoperator(this);
		}
	}

	public final ShiftoperatorContext shiftoperator() throws RecognitionException {
		ShiftoperatorContext _localctx = new ShiftoperatorContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_shiftoperator);
		try {
			setState(924);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Greater:
				enterOuterAlt(_localctx, 1);
				{
				setState(922);
				rightShift();
				}
				break;
			case Less:
				enterOuterAlt(_localctx, 2);
				{
				setState(923);
				leftShift();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RelationalexpressionContext extends ParserRuleContext {
		public ShiftexpressionContext shiftexpression() {
			return getRuleContext(ShiftexpressionContext.class,0);
		}
		public RelationalexpressionContext relationalexpression() {
			return getRuleContext(RelationalexpressionContext.class,0);
		}
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public TerminalNode LessEqual() { return getToken(CPP14Parser.LessEqual, 0); }
		public TerminalNode GreaterEqual() { return getToken(CPP14Parser.GreaterEqual, 0); }
		public RelationalexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relationalexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRelationalexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRelationalexpression(this);
		}
	}

	public final RelationalexpressionContext relationalexpression() throws RecognitionException {
		return relationalexpression(0);
	}

	private RelationalexpressionContext relationalexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		RelationalexpressionContext _localctx = new RelationalexpressionContext(_ctx, _parentState);
		RelationalexpressionContext _prevctx = _localctx;
		int _startState = 78;
		enterRecursionRule(_localctx, 78, RULE_relationalexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(927);
			shiftexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(940);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,67,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(938);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
					case 1:
						{
						_localctx = new RelationalexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_relationalexpression);
						setState(929);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(930);
						match(Greater);
						setState(931);
						shiftexpression(0);
						}
						break;
					case 2:
						{
						_localctx = new RelationalexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_relationalexpression);
						setState(932);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(933);
						match(LessEqual);
						setState(934);
						shiftexpression(0);
						}
						break;
					case 3:
						{
						_localctx = new RelationalexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_relationalexpression);
						setState(935);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(936);
						match(GreaterEqual);
						setState(937);
						shiftexpression(0);
						}
						break;
					}
					} 
				}
				setState(942);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,67,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EqualityexpressionContext extends ParserRuleContext {
		public RelationalexpressionContext relationalexpression() {
			return getRuleContext(RelationalexpressionContext.class,0);
		}
		public EqualityexpressionContext equalityexpression() {
			return getRuleContext(EqualityexpressionContext.class,0);
		}
		public TerminalNode Equal() { return getToken(CPP14Parser.Equal, 0); }
		public TerminalNode NotEqual() { return getToken(CPP14Parser.NotEqual, 0); }
		public EqualityexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_equalityexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEqualityexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEqualityexpression(this);
		}
	}

	public final EqualityexpressionContext equalityexpression() throws RecognitionException {
		return equalityexpression(0);
	}

	private EqualityexpressionContext equalityexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		EqualityexpressionContext _localctx = new EqualityexpressionContext(_ctx, _parentState);
		EqualityexpressionContext _prevctx = _localctx;
		int _startState = 80;
		enterRecursionRule(_localctx, 80, RULE_equalityexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(944);
			relationalexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(954);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(952);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
					case 1:
						{
						_localctx = new EqualityexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_equalityexpression);
						setState(946);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(947);
						match(Equal);
						setState(948);
						relationalexpression(0);
						}
						break;
					case 2:
						{
						_localctx = new EqualityexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_equalityexpression);
						setState(949);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(950);
						match(NotEqual);
						setState(951);
						relationalexpression(0);
						}
						break;
					}
					} 
				}
				setState(956);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AndexpressionContext extends ParserRuleContext {
		public EqualityexpressionContext equalityexpression() {
			return getRuleContext(EqualityexpressionContext.class,0);
		}
		public AndexpressionContext andexpression() {
			return getRuleContext(AndexpressionContext.class,0);
		}
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public AndexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_andexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAndexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAndexpression(this);
		}
	}

	public final AndexpressionContext andexpression() throws RecognitionException {
		return andexpression(0);
	}

	private AndexpressionContext andexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		AndexpressionContext _localctx = new AndexpressionContext(_ctx, _parentState);
		AndexpressionContext _prevctx = _localctx;
		int _startState = 82;
		enterRecursionRule(_localctx, 82, RULE_andexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(958);
			equalityexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(965);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new AndexpressionContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_andexpression);
					setState(960);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(961);
					match(And);
					setState(962);
					equalityexpression(0);
					}
					} 
				}
				setState(967);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExclusiveorexpressionContext extends ParserRuleContext {
		public AndexpressionContext andexpression() {
			return getRuleContext(AndexpressionContext.class,0);
		}
		public ExclusiveorexpressionContext exclusiveorexpression() {
			return getRuleContext(ExclusiveorexpressionContext.class,0);
		}
		public TerminalNode Caret() { return getToken(CPP14Parser.Caret, 0); }
		public ExclusiveorexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exclusiveorexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExclusiveorexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExclusiveorexpression(this);
		}
	}

	public final ExclusiveorexpressionContext exclusiveorexpression() throws RecognitionException {
		return exclusiveorexpression(0);
	}

	private ExclusiveorexpressionContext exclusiveorexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExclusiveorexpressionContext _localctx = new ExclusiveorexpressionContext(_ctx, _parentState);
		ExclusiveorexpressionContext _prevctx = _localctx;
		int _startState = 84;
		enterRecursionRule(_localctx, 84, RULE_exclusiveorexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(969);
			andexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(976);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,71,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new ExclusiveorexpressionContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_exclusiveorexpression);
					setState(971);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(972);
					match(Caret);
					setState(973);
					andexpression(0);
					}
					} 
				}
				setState(978);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,71,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InclusiveorexpressionContext extends ParserRuleContext {
		public ExclusiveorexpressionContext exclusiveorexpression() {
			return getRuleContext(ExclusiveorexpressionContext.class,0);
		}
		public InclusiveorexpressionContext inclusiveorexpression() {
			return getRuleContext(InclusiveorexpressionContext.class,0);
		}
		public TerminalNode Or() { return getToken(CPP14Parser.Or, 0); }
		public InclusiveorexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inclusiveorexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInclusiveorexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInclusiveorexpression(this);
		}
	}

	public final InclusiveorexpressionContext inclusiveorexpression() throws RecognitionException {
		return inclusiveorexpression(0);
	}

	private InclusiveorexpressionContext inclusiveorexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		InclusiveorexpressionContext _localctx = new InclusiveorexpressionContext(_ctx, _parentState);
		InclusiveorexpressionContext _prevctx = _localctx;
		int _startState = 86;
		enterRecursionRule(_localctx, 86, RULE_inclusiveorexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(980);
			exclusiveorexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(987);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new InclusiveorexpressionContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_inclusiveorexpression);
					setState(982);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(983);
					match(Or);
					setState(984);
					exclusiveorexpression(0);
					}
					} 
				}
				setState(989);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LogicalandexpressionContext extends ParserRuleContext {
		public InclusiveorexpressionContext inclusiveorexpression() {
			return getRuleContext(InclusiveorexpressionContext.class,0);
		}
		public LogicalandexpressionContext logicalandexpression() {
			return getRuleContext(LogicalandexpressionContext.class,0);
		}
		public AndoperatorContext andoperator() {
			return getRuleContext(AndoperatorContext.class,0);
		}
		public LogicalandexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicalandexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLogicalandexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLogicalandexpression(this);
		}
	}

	public final LogicalandexpressionContext logicalandexpression() throws RecognitionException {
		return logicalandexpression(0);
	}

	private LogicalandexpressionContext logicalandexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		LogicalandexpressionContext _localctx = new LogicalandexpressionContext(_ctx, _parentState);
		LogicalandexpressionContext _prevctx = _localctx;
		int _startState = 88;
		enterRecursionRule(_localctx, 88, RULE_logicalandexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(991);
			inclusiveorexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(1002);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(1000);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
					case 1:
						{
						_localctx = new LogicalandexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_logicalandexpression);
						setState(993);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(994);
						andoperator();
						setState(995);
						inclusiveorexpression(0);
						}
						break;
					case 2:
						{
						_localctx = new LogicalandexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_logicalandexpression);
						setState(997);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(998);
						match(T__2);
						setState(999);
						inclusiveorexpression(0);
						}
						break;
					}
					} 
				}
				setState(1004);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AndoperatorContext extends ParserRuleContext {
		public AndoperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_andoperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAndoperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAndoperator(this);
		}
	}

	public final AndoperatorContext andoperator() throws RecognitionException {
		AndoperatorContext _localctx = new AndoperatorContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_andoperator);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1005);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LogicalorexpressionContext extends ParserRuleContext {
		public LogicalandexpressionContext logicalandexpression() {
			return getRuleContext(LogicalandexpressionContext.class,0);
		}
		public LogicalorexpressionContext logicalorexpression() {
			return getRuleContext(LogicalorexpressionContext.class,0);
		}
		public OroperatorContext oroperator() {
			return getRuleContext(OroperatorContext.class,0);
		}
		public LogicalorexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicalorexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLogicalorexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLogicalorexpression(this);
		}
	}

	public final LogicalorexpressionContext logicalorexpression() throws RecognitionException {
		return logicalorexpression(0);
	}

	private LogicalorexpressionContext logicalorexpression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		LogicalorexpressionContext _localctx = new LogicalorexpressionContext(_ctx, _parentState);
		LogicalorexpressionContext _prevctx = _localctx;
		int _startState = 92;
		enterRecursionRule(_localctx, 92, RULE_logicalorexpression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1008);
			logicalandexpression(0);
			}
			_ctx.stop = _input.LT(-1);
			setState(1019);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(1017);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
					case 1:
						{
						_localctx = new LogicalorexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_logicalorexpression);
						setState(1010);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(1011);
						oroperator();
						setState(1012);
						logicalandexpression(0);
						}
						break;
					case 2:
						{
						_localctx = new LogicalorexpressionContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_logicalorexpression);
						setState(1014);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(1015);
						match(T__4);
						setState(1016);
						logicalandexpression(0);
						}
						break;
					}
					} 
				}
				setState(1021);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OroperatorContext extends ParserRuleContext {
		public OroperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_oroperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOroperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOroperator(this);
		}
	}

	public final OroperatorContext oroperator() throws RecognitionException {
		OroperatorContext _localctx = new OroperatorContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_oroperator);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1022);
			match(T__5);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConditionalexpressionContext extends ParserRuleContext {
		public LogicalorexpressionContext logicalorexpression() {
			return getRuleContext(LogicalorexpressionContext.class,0);
		}
		public TerminalNode Question() { return getToken(CPP14Parser.Question, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public AssignmentexpressionContext assignmentexpression() {
			return getRuleContext(AssignmentexpressionContext.class,0);
		}
		public ConditionalexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conditionalexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConditionalexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConditionalexpression(this);
		}
	}

	public final ConditionalexpressionContext conditionalexpression() throws RecognitionException {
		ConditionalexpressionContext _localctx = new ConditionalexpressionContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_conditionalexpression);
		try {
			setState(1031);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1024);
				logicalorexpression(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1025);
				logicalorexpression(0);
				setState(1026);
				match(Question);
				setState(1027);
				expression(0);
				setState(1028);
				match(Colon);
				setState(1029);
				assignmentexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AssignmentexpressionContext extends ParserRuleContext {
		public ConditionalexpressionContext conditionalexpression() {
			return getRuleContext(ConditionalexpressionContext.class,0);
		}
		public LogicalorexpressionContext logicalorexpression() {
			return getRuleContext(LogicalorexpressionContext.class,0);
		}
		public AssignmentoperatorContext assignmentoperator() {
			return getRuleContext(AssignmentoperatorContext.class,0);
		}
		public InitializerclauseContext initializerclause() {
			return getRuleContext(InitializerclauseContext.class,0);
		}
		public ThrowexpressionContext throwexpression() {
			return getRuleContext(ThrowexpressionContext.class,0);
		}
		public AssignmentexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignmentexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAssignmentexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAssignmentexpression(this);
		}
	}

	public final AssignmentexpressionContext assignmentexpression() throws RecognitionException {
		AssignmentexpressionContext _localctx = new AssignmentexpressionContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_assignmentexpression);
		try {
			setState(1039);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1033);
				conditionalexpression();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1034);
				logicalorexpression(0);
				setState(1035);
				assignmentoperator();
				setState(1036);
				initializerclause();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1038);
				throwexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AssignmentoperatorContext extends ParserRuleContext {
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public TerminalNode StarAssign() { return getToken(CPP14Parser.StarAssign, 0); }
		public TerminalNode DivAssign() { return getToken(CPP14Parser.DivAssign, 0); }
		public TerminalNode ModAssign() { return getToken(CPP14Parser.ModAssign, 0); }
		public TerminalNode PlusAssign() { return getToken(CPP14Parser.PlusAssign, 0); }
		public TerminalNode MinusAssign() { return getToken(CPP14Parser.MinusAssign, 0); }
		public RightShiftAssignContext rightShiftAssign() {
			return getRuleContext(RightShiftAssignContext.class,0);
		}
		public LeftShiftAssignContext leftShiftAssign() {
			return getRuleContext(LeftShiftAssignContext.class,0);
		}
		public TerminalNode AndAssign() { return getToken(CPP14Parser.AndAssign, 0); }
		public TerminalNode XorAssign() { return getToken(CPP14Parser.XorAssign, 0); }
		public TerminalNode OrAssign() { return getToken(CPP14Parser.OrAssign, 0); }
		public AssignmentoperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignmentoperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAssignmentoperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAssignmentoperator(this);
		}
	}

	public final AssignmentoperatorContext assignmentoperator() throws RecognitionException {
		AssignmentoperatorContext _localctx = new AssignmentoperatorContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_assignmentoperator);
		try {
			setState(1052);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Assign:
				enterOuterAlt(_localctx, 1);
				{
				setState(1041);
				match(Assign);
				}
				break;
			case StarAssign:
				enterOuterAlt(_localctx, 2);
				{
				setState(1042);
				match(StarAssign);
				}
				break;
			case DivAssign:
				enterOuterAlt(_localctx, 3);
				{
				setState(1043);
				match(DivAssign);
				}
				break;
			case ModAssign:
				enterOuterAlt(_localctx, 4);
				{
				setState(1044);
				match(ModAssign);
				}
				break;
			case PlusAssign:
				enterOuterAlt(_localctx, 5);
				{
				setState(1045);
				match(PlusAssign);
				}
				break;
			case MinusAssign:
				enterOuterAlt(_localctx, 6);
				{
				setState(1046);
				match(MinusAssign);
				}
				break;
			case Greater:
				enterOuterAlt(_localctx, 7);
				{
				setState(1047);
				rightShiftAssign();
				}
				break;
			case Less:
				enterOuterAlt(_localctx, 8);
				{
				setState(1048);
				leftShiftAssign();
				}
				break;
			case AndAssign:
				enterOuterAlt(_localctx, 9);
				{
				setState(1049);
				match(AndAssign);
				}
				break;
			case XorAssign:
				enterOuterAlt(_localctx, 10);
				{
				setState(1050);
				match(XorAssign);
				}
				break;
			case OrAssign:
				enterOuterAlt(_localctx, 11);
				{
				setState(1051);
				match(OrAssign);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExpressionContext extends ParserRuleContext {
		public AssignmentexpressionContext assignmentexpression() {
			return getRuleContext(AssignmentexpressionContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExpression(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		return expression(0);
	}

	private ExpressionContext expression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 102;
		enterRecursionRule(_localctx, 102, RULE_expression, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1055);
			assignmentexpression();
			}
			_ctx.stop = _input.LT(-1);
			setState(1062);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new ExpressionContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_expression);
					setState(1057);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1058);
					match(Comma);
					setState(1059);
					assignmentexpression();
					}
					} 
				}
				setState(1064);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConstantexpressionContext extends ParserRuleContext {
		public ConditionalexpressionContext conditionalexpression() {
			return getRuleContext(ConditionalexpressionContext.class,0);
		}
		public ConstantexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constantexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConstantexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConstantexpression(this);
		}
	}

	public final ConstantexpressionContext constantexpression() throws RecognitionException {
		ConstantexpressionContext _localctx = new ConstantexpressionContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_constantexpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1065);
			conditionalexpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StatementContext extends ParserRuleContext {
		public LabeledstatementContext labeledstatement() {
			return getRuleContext(LabeledstatementContext.class,0);
		}
		public ExpressionstatementContext expressionstatement() {
			return getRuleContext(ExpressionstatementContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public CompoundstatementContext compoundstatement() {
			return getRuleContext(CompoundstatementContext.class,0);
		}
		public SelectionstatementContext selectionstatement() {
			return getRuleContext(SelectionstatementContext.class,0);
		}
		public IterationstatementContext iterationstatement() {
			return getRuleContext(IterationstatementContext.class,0);
		}
		public JumpstatementContext jumpstatement() {
			return getRuleContext(JumpstatementContext.class,0);
		}
		public DeclarationstatementContext declarationstatement() {
			return getRuleContext(DeclarationstatementContext.class,0);
		}
		public TryblockContext tryblock() {
			return getRuleContext(TryblockContext.class,0);
		}
		public TerminalNode Noncontenctbrace() { return getToken(CPP14Parser.Noncontenctbrace, 0); }
		public StatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStatement(this);
		}
	}

	public final StatementContext statement() throws RecognitionException {
		StatementContext _localctx = new StatementContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_statement);
		int _la;
		try {
			setState(1094);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1067);
				labeledstatement();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1069);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
				case 1:
					{
					setState(1068);
					attributespecifierseq(0);
					}
					break;
				}
				setState(1071);
				expressionstatement();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1073);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1072);
					attributespecifierseq(0);
					}
				}

				setState(1075);
				compoundstatement();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1077);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1076);
					attributespecifierseq(0);
					}
				}

				setState(1079);
				selectionstatement();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1081);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1080);
					attributespecifierseq(0);
					}
				}

				setState(1083);
				iterationstatement();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(1085);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1084);
					attributespecifierseq(0);
					}
				}

				setState(1087);
				jumpstatement();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(1088);
				declarationstatement();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(1090);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1089);
					attributespecifierseq(0);
					}
				}

				setState(1092);
				tryblock();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(1093);
				match(Noncontenctbrace);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LabeledstatementContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public StatementContext statement() {
			return getRuleContext(StatementContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TerminalNode Case() { return getToken(CPP14Parser.Case, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public TerminalNode Default() { return getToken(CPP14Parser.Default, 0); }
		public LabeledstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_labeledstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLabeledstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLabeledstatement(this);
		}
	}

	public final LabeledstatementContext labeledstatement() throws RecognitionException {
		LabeledstatementContext _localctx = new LabeledstatementContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_labeledstatement);
		int _la;
		try {
			setState(1116);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1097);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1096);
					attributespecifierseq(0);
					}
				}

				setState(1099);
				match(Identifier);
				setState(1100);
				match(Colon);
				setState(1101);
				statement();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1103);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1102);
					attributespecifierseq(0);
					}
				}

				setState(1105);
				match(Case);
				setState(1106);
				constantexpression();
				setState(1107);
				match(Colon);
				setState(1108);
				statement();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1111);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1110);
					attributespecifierseq(0);
					}
				}

				setState(1113);
				match(Default);
				setState(1114);
				match(Colon);
				setState(1115);
				statement();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExpressionstatementContext extends ParserRuleContext {
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ExpressionstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expressionstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExpressionstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExpressionstatement(this);
		}
	}

	public final ExpressionstatementContext expressionstatement() throws RecognitionException {
		ExpressionstatementContext _localctx = new ExpressionstatementContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_expressionstatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1119);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911015785L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
				{
				setState(1118);
				expression(0);
				}
			}

			setState(1121);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CompoundstatementContext extends ParserRuleContext {
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public StatementseqContext statementseq() {
			return getRuleContext(StatementseqContext.class,0);
		}
		public TerminalNode Noncontenctbrace() { return getToken(CPP14Parser.Noncontenctbrace, 0); }
		public CompoundstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compoundstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCompoundstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCompoundstatement(this);
		}
	}

	public final CompoundstatementContext compoundstatement() throws RecognitionException {
		CompoundstatementContext _localctx = new CompoundstatementContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_compoundstatement);
		int _la;
		try {
			setState(1129);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LeftBrace:
				enterOuterAlt(_localctx, 1);
				{
				setState(1123);
				match(LeftBrace);
				setState(1125);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -33777075588464746L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 3485786142141839359L) != 0 || (((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 32519L) != 0) {
					{
					setState(1124);
					statementseq(0);
					}
				}

				setState(1127);
				match(RightBrace);
				}
				break;
			case Noncontenctbrace:
				enterOuterAlt(_localctx, 2);
				{
				setState(1128);
				match(Noncontenctbrace);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StatementseqContext extends ParserRuleContext {
		public StatementContext statement() {
			return getRuleContext(StatementContext.class,0);
		}
		public StatementseqContext statementseq() {
			return getRuleContext(StatementseqContext.class,0);
		}
		public StatementseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statementseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStatementseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStatementseq(this);
		}
	}

	public final StatementseqContext statementseq() throws RecognitionException {
		return statementseq(0);
	}

	private StatementseqContext statementseq(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		StatementseqContext _localctx = new StatementseqContext(_ctx, _parentState);
		StatementseqContext _prevctx = _localctx;
		int _startState = 114;
		enterRecursionRule(_localctx, 114, RULE_statementseq, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1132);
			statement();
			}
			_ctx.stop = _input.LT(-1);
			setState(1138);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new StatementseqContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_statementseq);
					setState(1134);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1135);
					statement();
					}
					} 
				}
				setState(1140);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SelectionstatementContext extends ParserRuleContext {
		public TerminalNode If() { return getToken(CPP14Parser.If, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ConditionContext condition() {
			return getRuleContext(ConditionContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public List<StatementContext> statement() {
			return getRuleContexts(StatementContext.class);
		}
		public StatementContext statement(int i) {
			return getRuleContext(StatementContext.class,i);
		}
		public TerminalNode Else() { return getToken(CPP14Parser.Else, 0); }
		public TerminalNode Switch() { return getToken(CPP14Parser.Switch, 0); }
		public SelectionstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectionstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSelectionstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSelectionstatement(this);
		}
	}

	public final SelectionstatementContext selectionstatement() throws RecognitionException {
		SelectionstatementContext _localctx = new SelectionstatementContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_selectionstatement);
		try {
			setState(1161);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1141);
				match(If);
				setState(1142);
				match(LeftParen);
				setState(1143);
				condition();
				setState(1144);
				match(RightParen);
				setState(1145);
				statement();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1147);
				match(If);
				setState(1148);
				match(LeftParen);
				setState(1149);
				condition();
				setState(1150);
				match(RightParen);
				setState(1151);
				statement();
				setState(1152);
				match(Else);
				setState(1153);
				statement();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1155);
				match(Switch);
				setState(1156);
				match(LeftParen);
				setState(1157);
				condition();
				setState(1158);
				match(RightParen);
				setState(1159);
				statement();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConditionContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public DeclspecifierseqContext declspecifierseq() {
			return getRuleContext(DeclspecifierseqContext.class,0);
		}
		public DeclaratorContext declarator() {
			return getRuleContext(DeclaratorContext.class,0);
		}
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public InitializerclauseContext initializerclause() {
			return getRuleContext(InitializerclauseContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public ConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_condition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCondition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCondition(this);
		}
	}

	public final ConditionContext condition() throws RecognitionException {
		ConditionContext _localctx = new ConditionContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_condition);
		int _la;
		try {
			setState(1179);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1163);
				expression(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1165);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1164);
					attributespecifierseq(0);
					}
				}

				setState(1167);
				declspecifierseq();
				setState(1168);
				declarator();
				setState(1169);
				match(Assign);
				setState(1170);
				initializerclause();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1173);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1172);
					attributespecifierseq(0);
					}
				}

				setState(1175);
				declspecifierseq();
				setState(1176);
				declarator();
				setState(1177);
				bracedinitlist();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IterationstatementContext extends ParserRuleContext {
		public TerminalNode While() { return getToken(CPP14Parser.While, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ConditionContext condition() {
			return getRuleContext(ConditionContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public StatementContext statement() {
			return getRuleContext(StatementContext.class,0);
		}
		public TerminalNode Do() { return getToken(CPP14Parser.Do, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public TerminalNode For() { return getToken(CPP14Parser.For, 0); }
		public ForinitstatementContext forinitstatement() {
			return getRuleContext(ForinitstatementContext.class,0);
		}
		public ForrangedeclarationContext forrangedeclaration() {
			return getRuleContext(ForrangedeclarationContext.class,0);
		}
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public ForrangeinitializerContext forrangeinitializer() {
			return getRuleContext(ForrangeinitializerContext.class,0);
		}
		public IterationstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_iterationstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterIterationstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitIterationstatement(this);
		}
	}

	public final IterationstatementContext iterationstatement() throws RecognitionException {
		IterationstatementContext _localctx = new IterationstatementContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_iterationstatement);
		int _la;
		try {
			setState(1216);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1181);
				match(While);
				setState(1182);
				match(LeftParen);
				setState(1183);
				condition();
				setState(1184);
				match(RightParen);
				setState(1185);
				statement();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1187);
				match(Do);
				setState(1188);
				statement();
				setState(1189);
				match(While);
				setState(1190);
				match(LeftParen);
				setState(1191);
				expression(0);
				setState(1192);
				match(RightParen);
				setState(1193);
				match(Semi);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1195);
				match(For);
				setState(1196);
				match(LeftParen);
				setState(1197);
				forinitstatement();
				setState(1199);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -4789652224424862970L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911097725L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(1198);
					condition();
					}
				}

				setState(1201);
				match(Semi);
				setState(1203);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911015785L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(1202);
					expression(0);
					}
				}

				setState(1205);
				match(RightParen);
				setState(1206);
				statement();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1208);
				match(For);
				setState(1209);
				match(LeftParen);
				setState(1210);
				forrangedeclaration();
				setState(1211);
				match(Colon);
				setState(1212);
				forrangeinitializer();
				setState(1213);
				match(RightParen);
				setState(1214);
				statement();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ForinitstatementContext extends ParserRuleContext {
		public ExpressionstatementContext expressionstatement() {
			return getRuleContext(ExpressionstatementContext.class,0);
		}
		public SimpledeclarationContext simpledeclaration() {
			return getRuleContext(SimpledeclarationContext.class,0);
		}
		public ForinitstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_forinitstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterForinitstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitForinitstatement(this);
		}
	}

	public final ForinitstatementContext forinitstatement() throws RecognitionException {
		ForinitstatementContext _localctx = new ForinitstatementContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_forinitstatement);
		try {
			setState(1220);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1218);
				expressionstatement();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1219);
				simpledeclaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ForrangedeclarationContext extends ParserRuleContext {
		public DeclspecifierseqContext declspecifierseq() {
			return getRuleContext(DeclspecifierseqContext.class,0);
		}
		public DeclaratorContext declarator() {
			return getRuleContext(DeclaratorContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public ForrangedeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_forrangedeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterForrangedeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitForrangedeclaration(this);
		}
	}

	public final ForrangedeclarationContext forrangedeclaration() throws RecognitionException {
		ForrangedeclarationContext _localctx = new ForrangedeclarationContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_forrangedeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1223);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Alignas || _la==LeftBracket) {
				{
				setState(1222);
				attributespecifierseq(0);
				}
			}

			setState(1225);
			declspecifierseq();
			setState(1226);
			declarator();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ForrangeinitializerContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public ForrangeinitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_forrangeinitializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterForrangeinitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitForrangeinitializer(this);
		}
	}

	public final ForrangeinitializerContext forrangeinitializer() throws RecognitionException {
		ForrangeinitializerContext _localctx = new ForrangeinitializerContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_forrangeinitializer);
		try {
			setState(1230);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__0:
			case T__1:
			case Alignof:
			case Auto:
			case Bool:
			case Char:
			case Char16:
			case Char32:
			case Const_cast:
			case Decltype:
			case Delete:
			case Double:
			case Dynamic_cast:
			case False:
			case Float:
			case Int:
			case Long:
			case New:
			case Noexcept:
			case Nullptr:
			case Operator:
			case Reinterpret_cast:
			case Short:
			case Signed:
			case Sizeof:
			case Static_cast:
			case Struct:
			case This:
			case Throw:
			case True:
			case Typedef:
			case Typeid_:
			case Typename_:
			case Unsigned:
			case Void:
			case Wchar:
			case LeftParen:
			case LeftBracket:
			case Plus:
			case Minus:
			case Star:
			case And:
			case Or:
			case Tilde:
			case PlusPlus:
			case MinusMinus:
			case Doublecolon:
			case Identifier:
			case Integerliteral:
			case Characterliteral:
			case Floatingliteral:
			case Stringliteral:
			case Userdefinedintegerliteral:
			case Userdefinedfloatingliteral:
			case Userdefinedstringliteral:
			case Userdefinedcharacterliteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(1228);
				expression(0);
				}
				break;
			case LeftBrace:
				enterOuterAlt(_localctx, 2);
				{
				setState(1229);
				bracedinitlist();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class JumpstatementContext extends ParserRuleContext {
		public TerminalNode Break() { return getToken(CPP14Parser.Break, 0); }
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public TerminalNode Continue() { return getToken(CPP14Parser.Continue, 0); }
		public TerminalNode Return() { return getToken(CPP14Parser.Return, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public TerminalNode Goto() { return getToken(CPP14Parser.Goto, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public JumpstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_jumpstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterJumpstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitJumpstatement(this);
		}
	}

	public final JumpstatementContext jumpstatement() throws RecognitionException {
		JumpstatementContext _localctx = new JumpstatementContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_jumpstatement);
		int _la;
		try {
			setState(1248);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1232);
				match(Break);
				setState(1233);
				match(Semi);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1234);
				match(Continue);
				setState(1235);
				match(Semi);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1236);
				match(Return);
				setState(1238);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911015785L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(1237);
					expression(0);
					}
				}

				setState(1240);
				match(Semi);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1241);
				match(Return);
				setState(1242);
				bracedinitlist();
				setState(1243);
				match(Semi);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1245);
				match(Goto);
				setState(1246);
				match(Identifier);
				setState(1247);
				match(Semi);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeclarationstatementContext extends ParserRuleContext {
		public BlockdeclarationContext blockdeclaration() {
			return getRuleContext(BlockdeclarationContext.class,0);
		}
		public DeclarationstatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declarationstatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclarationstatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclarationstatement(this);
		}
	}

	public final DeclarationstatementContext declarationstatement() throws RecognitionException {
		DeclarationstatementContext _localctx = new DeclarationstatementContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_declarationstatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1250);
			blockdeclaration();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeclarationseqContext extends ParserRuleContext {
		public DeclarationContext declaration() {
			return getRuleContext(DeclarationContext.class,0);
		}
		public DeclarationseqContext declarationseq() {
			return getRuleContext(DeclarationseqContext.class,0);
		}
		public DeclarationseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declarationseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclarationseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclarationseq(this);
		}
	}

	public final DeclarationseqContext declarationseq() throws RecognitionException {
		return declarationseq(0);
	}

	private DeclarationseqContext declarationseq(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		DeclarationseqContext _localctx = new DeclarationseqContext(_ctx, _parentState);
		DeclarationseqContext _prevctx = _localctx;
		int _startState = 132;
		enterRecursionRule(_localctx, 132, RULE_declarationseq, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1253);
			declaration();
			}
			_ctx.stop = _input.LT(-1);
			setState(1259);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new DeclarationseqContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_declarationseq);
					setState(1255);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1256);
					declaration();
					}
					} 
				}
				setState(1261);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeclarationContext extends ParserRuleContext {
		public BlockdeclarationContext blockdeclaration() {
			return getRuleContext(BlockdeclarationContext.class,0);
		}
		public FunctiondefinitionContext functiondefinition() {
			return getRuleContext(FunctiondefinitionContext.class,0);
		}
		public TemplatedeclarationContext templatedeclaration() {
			return getRuleContext(TemplatedeclarationContext.class,0);
		}
		public ExplicitinstantiationContext explicitinstantiation() {
			return getRuleContext(ExplicitinstantiationContext.class,0);
		}
		public ExplicitspecializationContext explicitspecialization() {
			return getRuleContext(ExplicitspecializationContext.class,0);
		}
		public LinkagespecificationContext linkagespecification() {
			return getRuleContext(LinkagespecificationContext.class,0);
		}
		public NamespacedefinitionContext namespacedefinition() {
			return getRuleContext(NamespacedefinitionContext.class,0);
		}
		public EmptydeclarationContext emptydeclaration() {
			return getRuleContext(EmptydeclarationContext.class,0);
		}
		public AttributedeclarationContext attributedeclaration() {
			return getRuleContext(AttributedeclarationContext.class,0);
		}
		public DeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclaration(this);
		}
	}

	public final DeclarationContext declaration() throws RecognitionException {
		DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_declaration);
		try {
			setState(1271);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1262);
				blockdeclaration();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1263);
				functiondefinition();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1264);
				templatedeclaration();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1265);
				explicitinstantiation();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1266);
				explicitspecialization();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(1267);
				linkagespecification();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(1268);
				namespacedefinition();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(1269);
				emptydeclaration();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(1270);
				attributedeclaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BlockdeclarationContext extends ParserRuleContext {
		public SimpledeclarationContext simpledeclaration() {
			return getRuleContext(SimpledeclarationContext.class,0);
		}
		public AsmdefinitionContext asmdefinition() {
			return getRuleContext(AsmdefinitionContext.class,0);
		}
		public NamespacealiasdefinitionContext namespacealiasdefinition() {
			return getRuleContext(NamespacealiasdefinitionContext.class,0);
		}
		public UsingdeclarationContext usingdeclaration() {
			return getRuleContext(UsingdeclarationContext.class,0);
		}
		public UsingdirectiveContext usingdirective() {
			return getRuleContext(UsingdirectiveContext.class,0);
		}
		public Static_assertdeclarationContext static_assertdeclaration() {
			return getRuleContext(Static_assertdeclarationContext.class,0);
		}
		public AliasdeclarationContext aliasdeclaration() {
			return getRuleContext(AliasdeclarationContext.class,0);
		}
		public OpaqueenumdeclarationContext opaqueenumdeclaration() {
			return getRuleContext(OpaqueenumdeclarationContext.class,0);
		}
		public BlockdeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blockdeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBlockdeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBlockdeclaration(this);
		}
	}

	public final BlockdeclarationContext blockdeclaration() throws RecognitionException {
		BlockdeclarationContext _localctx = new BlockdeclarationContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_blockdeclaration);
		try {
			setState(1281);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1273);
				simpledeclaration();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1274);
				asmdefinition();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1275);
				namespacealiasdefinition();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1276);
				usingdeclaration();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1277);
				usingdirective();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(1278);
				static_assertdeclaration();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(1279);
				aliasdeclaration();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(1280);
				opaqueenumdeclaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AliasdeclarationContext extends ParserRuleContext {
		public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public AliasdeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aliasdeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAliasdeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAliasdeclaration(this);
		}
	}

	public final AliasdeclarationContext aliasdeclaration() throws RecognitionException {
		AliasdeclarationContext _localctx = new AliasdeclarationContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_aliasdeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1283);
			match(Using);
			setState(1284);
			match(Identifier);
			setState(1286);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Alignas || _la==LeftBracket) {
				{
				setState(1285);
				attributespecifierseq(0);
				}
			}

			setState(1288);
			match(Assign);
			setState(1289);
			thetypeid();
			setState(1290);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SimpledeclarationContext extends ParserRuleContext {
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public DeclspecifierseqContext declspecifierseq() {
			return getRuleContext(DeclspecifierseqContext.class,0);
		}
		public InitdeclaratorlistContext initdeclaratorlist() {
			return getRuleContext(InitdeclaratorlistContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public SimpledeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_simpledeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimpledeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimpledeclaration(this);
		}
	}

	public final SimpledeclarationContext simpledeclaration() throws RecognitionException {
		SimpledeclarationContext _localctx = new SimpledeclarationContext(_ctx, getState());
		enterRule(_localctx, 140, RULE_simpledeclaration);
		int _la;
		try {
			setState(1306);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__3:
			case Auto:
			case Bool:
			case Char:
			case Char16:
			case Char32:
			case Class:
			case Const:
			case Constexpr:
			case Decltype:
			case Double:
			case Enum:
			case Explicit:
			case Extern:
			case Float:
			case Friend:
			case Inline:
			case Int:
			case Long:
			case Mutable:
			case Operator:
			case Register:
			case Short:
			case Signed:
			case Static:
			case Struct:
			case Template:
			case Thread_local:
			case Typedef:
			case Typename_:
			case Unsigned:
			case Virtual:
			case Void:
			case Volatile:
			case Wchar:
			case LeftParen:
			case Star:
			case And:
			case Tilde:
			case Doublecolon:
			case Semi:
			case Ellipsis:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(1293);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
				case 1:
					{
					setState(1292);
					declspecifierseq();
					}
					break;
				}
				setState(1296);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & 1125899923619856L) != 0 || (((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 53876069781761L) != 0) {
					{
					setState(1295);
					initdeclaratorlist(0);
					}
				}

				setState(1298);
				match(Semi);
				}
				break;
			case Alignas:
			case LeftBracket:
				enterOuterAlt(_localctx, 2);
				{
				setState(1299);
				attributespecifierseq(0);
				setState(1301);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
				case 1:
					{
					setState(1300);
					declspecifierseq();
					}
					break;
				}
				setState(1303);
				initdeclaratorlist(0);
				setState(1304);
				match(Semi);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Static_assertdeclarationContext extends ParserRuleContext {
		public TerminalNode Static_assert() { return getToken(CPP14Parser.Static_assert, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public Static_assertdeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_static_assertdeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStatic_assertdeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStatic_assertdeclaration(this);
		}
	}

	public final Static_assertdeclarationContext static_assertdeclaration() throws RecognitionException {
		Static_assertdeclarationContext _localctx = new Static_assertdeclarationContext(_ctx, getState());
		enterRule(_localctx, 142, RULE_static_assertdeclaration);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1308);
			match(Static_assert);
			setState(1309);
			match(LeftParen);
			setState(1310);
			constantexpression();
			setState(1311);
			match(Comma);
			setState(1312);
			match(Stringliteral);
			setState(1313);
			match(RightParen);
			setState(1314);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EmptydeclarationContext extends ParserRuleContext {
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public EmptydeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_emptydeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEmptydeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEmptydeclaration(this);
		}
	}

	public final EmptydeclarationContext emptydeclaration() throws RecognitionException {
		EmptydeclarationContext _localctx = new EmptydeclarationContext(_ctx, getState());
		enterRule(_localctx, 144, RULE_emptydeclaration);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1316);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributedeclarationContext extends ParserRuleContext {
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public AttributedeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributedeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributedeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributedeclaration(this);
		}
	}

	public final AttributedeclarationContext attributedeclaration() throws RecognitionException {
		AttributedeclarationContext _localctx = new AttributedeclarationContext(_ctx, getState());
		enterRule(_localctx, 146, RULE_attributedeclaration);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1318);
			attributespecifierseq(0);
			setState(1319);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeclspecifierContext extends ParserRuleContext {
		public StorageclassspecifierContext storageclassspecifier() {
			return getRuleContext(StorageclassspecifierContext.class,0);
		}
		public TypespecifierContext typespecifier() {
			return getRuleContext(TypespecifierContext.class,0);
		}
		public FunctionspecifierContext functionspecifier() {
			return getRuleContext(FunctionspecifierContext.class,0);
		}
		public TerminalNode Friend() { return getToken(CPP14Parser.Friend, 0); }
		public TerminalNode Typedef() { return getToken(CPP14Parser.Typedef, 0); }
		public TerminalNode Constexpr() { return getToken(CPP14Parser.Constexpr, 0); }
		public DeclspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclspecifier(this);
		}
	}

	public final DeclspecifierContext declspecifier() throws RecognitionException {
		DeclspecifierContext _localctx = new DeclspecifierContext(_ctx, getState());
		enterRule(_localctx, 148, RULE_declspecifier);
		try {
			setState(1327);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1321);
				storageclassspecifier();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1322);
				typespecifier();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1323);
				functionspecifier();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1324);
				match(Friend);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1325);
				match(Typedef);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(1326);
				match(Constexpr);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeclspecifierseqContext extends ParserRuleContext {
		public DeclspecifierContext declspecifier() {
			return getRuleContext(DeclspecifierContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public DeclspecifierseqContext declspecifierseq() {
			return getRuleContext(DeclspecifierseqContext.class,0);
		}
		public DeclspecifierseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declspecifierseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclspecifierseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclspecifierseq(this);
		}
	}

	public final DeclspecifierseqContext declspecifierseq() throws RecognitionException {
		DeclspecifierseqContext _localctx = new DeclspecifierseqContext(_ctx, getState());
		enterRule(_localctx, 150, RULE_declspecifierseq);
		try {
			setState(1336);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1329);
				declspecifier();
				setState(1331);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
				case 1:
					{
					setState(1330);
					attributespecifierseq(0);
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1333);
				declspecifier();
				setState(1334);
				declspecifierseq();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StorageclassspecifierContext extends ParserRuleContext {
		public TerminalNode Register() { return getToken(CPP14Parser.Register, 0); }
		public TerminalNode Static() { return getToken(CPP14Parser.Static, 0); }
		public TerminalNode Thread_local() { return getToken(CPP14Parser.Thread_local, 0); }
		public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); }
		public TerminalNode Mutable() { return getToken(CPP14Parser.Mutable, 0); }
		public StorageclassspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_storageclassspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStorageclassspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStorageclassspecifier(this);
		}
	}

	public final StorageclassspecifierContext storageclassspecifier() throws RecognitionException {
		StorageclassspecifierContext _localctx = new StorageclassspecifierContext(_ctx, getState());
		enterRule(_localctx, 152, RULE_storageclassspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1338);
			_la = _input.LA(1);
			if ( !((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & 17316186113L) != 0) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FunctionspecifierContext extends ParserRuleContext {
		public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
		public TerminalNode Virtual() { return getToken(CPP14Parser.Virtual, 0); }
		public TerminalNode Explicit() { return getToken(CPP14Parser.Explicit, 0); }
		public FunctionspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functionspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctionspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctionspecifier(this);
		}
	}

	public final FunctionspecifierContext functionspecifier() throws RecognitionException {
		FunctionspecifierContext _localctx = new FunctionspecifierContext(_ctx, getState());
		enterRule(_localctx, 154, RULE_functionspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1340);
			_la = _input.LA(1);
			if ( !((((_la - 32)) & ~0x3f) == 0 && ((1L << (_la - 32)) & 70368744178689L) != 0) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypedefnameContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TypedefnameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typedefname; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypedefname(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypedefname(this);
		}
	}

	public final TypedefnameContext typedefname() throws RecognitionException {
		TypedefnameContext _localctx = new TypedefnameContext(_ctx, getState());
		enterRule(_localctx, 156, RULE_typedefname);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1342);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StructnameContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public StructnameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_structname; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStructname(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStructname(this);
		}
	}

	public final StructnameContext structname() throws RecognitionException {
		StructnameContext _localctx = new StructnameContext(_ctx, getState());
		enterRule(_localctx, 158, RULE_structname);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1344);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypespecifierContext extends ParserRuleContext {
		public TrailingtypespecifierContext trailingtypespecifier() {
			return getRuleContext(TrailingtypespecifierContext.class,0);
		}
		public InheritclassspecifierContext inheritclassspecifier() {
			return getRuleContext(InheritclassspecifierContext.class,0);
		}
		public EnumspecifierContext enumspecifier() {
			return getRuleContext(EnumspecifierContext.class,0);
		}
		public BaseclassspecifierContext baseclassspecifier() {
			return getRuleContext(BaseclassspecifierContext.class,0);
		}
		public TypedefspecifierContext typedefspecifier() {
			return getRuleContext(TypedefspecifierContext.class,0);
		}
		public InherittypedefspecifierContext inherittypedefspecifier() {
			return getRuleContext(InherittypedefspecifierContext.class,0);
		}
		public TypespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypespecifier(this);
		}
	}

	public final TypespecifierContext typespecifier() throws RecognitionException {
		TypespecifierContext _localctx = new TypespecifierContext(_ctx, getState());
		enterRule(_localctx, 160, RULE_typespecifier);
		try {
			setState(1352);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1346);
				trailingtypespecifier();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1347);
				inheritclassspecifier();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1348);
				enumspecifier();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1349);
				baseclassspecifier();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1350);
				typedefspecifier();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(1351);
				inherittypedefspecifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TrailingtypespecifierContext extends ParserRuleContext {
		public SimpletypespecifierContext simpletypespecifier() {
			return getRuleContext(SimpletypespecifierContext.class,0);
		}
		public ElaboratedtypespecifierContext elaboratedtypespecifier() {
			return getRuleContext(ElaboratedtypespecifierContext.class,0);
		}
		public TypenamespecifierContext typenamespecifier() {
			return getRuleContext(TypenamespecifierContext.class,0);
		}
		public CvqualifierContext cvqualifier() {
			return getRuleContext(CvqualifierContext.class,0);
		}
		public TrailingtypespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_trailingtypespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTrailingtypespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTrailingtypespecifier(this);
		}
	}

	public final TrailingtypespecifierContext trailingtypespecifier() throws RecognitionException {
		TrailingtypespecifierContext _localctx = new TrailingtypespecifierContext(_ctx, getState());
		enterRule(_localctx, 162, RULE_trailingtypespecifier);
		try {
			setState(1358);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Auto:
			case Bool:
			case Char:
			case Char16:
			case Char32:
			case Decltype:
			case Double:
			case Float:
			case Int:
			case Long:
			case Short:
			case Signed:
			case Struct:
			case Typedef:
			case Unsigned:
			case Void:
			case Wchar:
			case Doublecolon:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(1354);
				simpletypespecifier();
				}
				break;
			case Class:
			case Enum:
			case Template:
				enterOuterAlt(_localctx, 2);
				{
				setState(1355);
				elaboratedtypespecifier();
				}
				break;
			case Typename_:
				enterOuterAlt(_localctx, 3);
				{
				setState(1356);
				typenamespecifier();
				}
				break;
			case Const:
			case Volatile:
				enterOuterAlt(_localctx, 4);
				{
				setState(1357);
				cvqualifier();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypespecifierseqContext extends ParserRuleContext {
		public TypespecifierContext typespecifier() {
			return getRuleContext(TypespecifierContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TypespecifierseqContext typespecifierseq() {
			return getRuleContext(TypespecifierseqContext.class,0);
		}
		public TypespecifierseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typespecifierseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypespecifierseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypespecifierseq(this);
		}
	}

	public final TypespecifierseqContext typespecifierseq() throws RecognitionException {
		TypespecifierseqContext _localctx = new TypespecifierseqContext(_ctx, getState());
		enterRule(_localctx, 164, RULE_typespecifierseq);
		try {
			setState(1367);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1360);
				typespecifier();
				setState(1362);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
				case 1:
					{
					setState(1361);
					attributespecifierseq(0);
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1364);
				typespecifier();
				setState(1365);
				typespecifierseq();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TrailingtypespecifierseqContext extends ParserRuleContext {
		public TrailingtypespecifierContext trailingtypespecifier() {
			return getRuleContext(TrailingtypespecifierContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TrailingtypespecifierseqContext trailingtypespecifierseq() {
			return getRuleContext(TrailingtypespecifierseqContext.class,0);
		}
		public TrailingtypespecifierseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_trailingtypespecifierseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTrailingtypespecifierseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTrailingtypespecifierseq(this);
		}
	}

	public final TrailingtypespecifierseqContext trailingtypespecifierseq() throws RecognitionException {
		TrailingtypespecifierseqContext _localctx = new TrailingtypespecifierseqContext(_ctx, getState());
		enterRule(_localctx, 166, RULE_trailingtypespecifierseq);
		try {
			setState(1376);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1369);
				trailingtypespecifier();
				setState(1371);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
				case 1:
					{
					setState(1370);
					attributespecifierseq(0);
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1373);
				trailingtypespecifier();
				setState(1374);
				trailingtypespecifierseq();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SimpletypespecifierContext extends ParserRuleContext {
		public ThetypenameContext thetypename() {
			return getRuleContext(ThetypenameContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public TerminalNode Typedef() { return getToken(CPP14Parser.Typedef, 0); }
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public TerminalNode Char() { return getToken(CPP14Parser.Char, 0); }
		public TerminalNode Char16() { return getToken(CPP14Parser.Char16, 0); }
		public TerminalNode Char32() { return getToken(CPP14Parser.Char32, 0); }
		public TerminalNode Wchar() { return getToken(CPP14Parser.Wchar, 0); }
		public TerminalNode Bool() { return getToken(CPP14Parser.Bool, 0); }
		public TerminalNode Short() { return getToken(CPP14Parser.Short, 0); }
		public TerminalNode Int() { return getToken(CPP14Parser.Int, 0); }
		public TerminalNode Long() { return getToken(CPP14Parser.Long, 0); }
		public TerminalNode Signed() { return getToken(CPP14Parser.Signed, 0); }
		public TerminalNode Unsigned() { return getToken(CPP14Parser.Unsigned, 0); }
		public TerminalNode Float() { return getToken(CPP14Parser.Float, 0); }
		public TerminalNode Double() { return getToken(CPP14Parser.Double, 0); }
		public TerminalNode Void() { return getToken(CPP14Parser.Void, 0); }
		public TerminalNode Auto() { return getToken(CPP14Parser.Auto, 0); }
		public TerminalNode Struct() { return getToken(CPP14Parser.Struct, 0); }
		public DecltypespecifierContext decltypespecifier() {
			return getRuleContext(DecltypespecifierContext.class,0);
		}
		public SimpletypespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_simpletypespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimpletypespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimpletypespecifier(this);
		}
	}

	public final SimpletypespecifierContext simpletypespecifier() throws RecognitionException {
		SimpletypespecifierContext _localctx = new SimpletypespecifierContext(_ctx, getState());
		enterRule(_localctx, 168, RULE_simpletypespecifier);
		int _la;
		try {
			setState(1405);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1379);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
				case 1:
					{
					setState(1378);
					nestednamespecifier(0);
					}
					break;
				}
				setState(1382);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Typedef) {
					{
					setState(1381);
					match(Typedef);
					}
				}

				setState(1384);
				thetypename();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1385);
				nestednamespecifier(0);
				setState(1386);
				match(Template);
				setState(1387);
				simpletemplateid();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1389);
				match(Char);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1390);
				match(Char16);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1391);
				match(Char32);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(1392);
				match(Wchar);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(1393);
				match(Bool);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(1394);
				match(Short);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(1395);
				match(Int);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(1396);
				match(Long);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(1397);
				match(Signed);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(1398);
				match(Unsigned);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(1399);
				match(Float);
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(1400);
				match(Double);
				}
				break;
			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(1401);
				match(Void);
				}
				break;
			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(1402);
				match(Auto);
				}
				break;
			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(1403);
				match(Struct);
				}
				break;
			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(1404);
				decltypespecifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ThetypenameContext extends ParserRuleContext {
		public ClassnameContext classname() {
			return getRuleContext(ClassnameContext.class,0);
		}
		public EnumnameContext enumname() {
			return getRuleContext(EnumnameContext.class,0);
		}
		public TypedefnameContext typedefname() {
			return getRuleContext(TypedefnameContext.class,0);
		}
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public ThetypenameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_thetypename; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterThetypename(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitThetypename(this);
		}
	}

	public final ThetypenameContext thetypename() throws RecognitionException {
		ThetypenameContext _localctx = new ThetypenameContext(_ctx, getState());
		enterRule(_localctx, 170, RULE_thetypename);
		try {
			setState(1411);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1407);
				classname();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1408);
				enumname();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1409);
				typedefname();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1410);
				simpletemplateid();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DecltypespecifierContext extends ParserRuleContext {
		public TerminalNode Decltype() { return getToken(CPP14Parser.Decltype, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TerminalNode Auto() { return getToken(CPP14Parser.Auto, 0); }
		public DecltypespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_decltypespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDecltypespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDecltypespecifier(this);
		}
	}

	public final DecltypespecifierContext decltypespecifier() throws RecognitionException {
		DecltypespecifierContext _localctx = new DecltypespecifierContext(_ctx, getState());
		enterRule(_localctx, 172, RULE_decltypespecifier);
		try {
			setState(1422);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1413);
				match(Decltype);
				setState(1414);
				match(LeftParen);
				setState(1415);
				expression(0);
				setState(1416);
				match(RightParen);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1418);
				match(Decltype);
				setState(1419);
				match(LeftParen);
				setState(1420);
				match(Auto);
				setState(1421);
				match(RightParen);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ElaboratedtypespecifierContext extends ParserRuleContext {
		public ClasskeyContext classkey() {
			return getRuleContext(ClasskeyContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public TerminalNode Enum() { return getToken(CPP14Parser.Enum, 0); }
		public ElaboratedtypespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_elaboratedtypespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterElaboratedtypespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitElaboratedtypespecifier(this);
		}
	}

	public final ElaboratedtypespecifierContext elaboratedtypespecifier() throws RecognitionException {
		ElaboratedtypespecifierContext _localctx = new ElaboratedtypespecifierContext(_ctx, getState());
		enterRule(_localctx, 174, RULE_elaboratedtypespecifier);
		int _la;
		try {
			setState(1451);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1424);
				classkey();
				setState(1426);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1425);
					attributespecifierseq(0);
					}
				}

				setState(1429);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
				case 1:
					{
					setState(1428);
					nestednamespecifier(0);
					}
					break;
				}
				setState(1431);
				match(Identifier);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1434);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Template) {
					{
					setState(1433);
					match(Template);
					}
				}

				setState(1436);
				classkey();
				setState(1437);
				simpletemplateid();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1439);
				classkey();
				setState(1440);
				nestednamespecifier(0);
				setState(1442);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Template) {
					{
					setState(1441);
					match(Template);
					}
				}

				setState(1444);
				simpletemplateid();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1446);
				match(Enum);
				setState(1448);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
				case 1:
					{
					setState(1447);
					nestednamespecifier(0);
					}
					break;
				}
				setState(1450);
				match(Identifier);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumnameContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public EnumnameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumname; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumname(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumname(this);
		}
	}

	public final EnumnameContext enumname() throws RecognitionException {
		EnumnameContext _localctx = new EnumnameContext(_ctx, getState());
		enterRule(_localctx, 176, RULE_enumname);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1453);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumspecifierContext extends ParserRuleContext {
		public EnumheadContext enumhead() {
			return getRuleContext(EnumheadContext.class,0);
		}
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public EnumeratorlistContext enumeratorlist() {
			return getRuleContext(EnumeratorlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public EnumspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumspecifier(this);
		}
	}

	public final EnumspecifierContext enumspecifier() throws RecognitionException {
		EnumspecifierContext _localctx = new EnumspecifierContext(_ctx, getState());
		enterRule(_localctx, 178, RULE_enumspecifier);
		int _la;
		try {
			setState(1468);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1455);
				enumhead();
				setState(1456);
				match(LeftBrace);
				setState(1458);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Identifier) {
					{
					setState(1457);
					enumeratorlist(0);
					}
				}

				setState(1460);
				match(RightBrace);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1462);
				enumhead();
				setState(1463);
				match(LeftBrace);
				setState(1464);
				enumeratorlist(0);
				setState(1465);
				match(Comma);
				setState(1466);
				match(RightBrace);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumheadContext extends ParserRuleContext {
		public EnumkeyContext enumkey() {
			return getRuleContext(EnumkeyContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public EnumbaseContext enumbase() {
			return getRuleContext(EnumbaseContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public EnumheadContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumhead; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumhead(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumhead(this);
		}
	}

	public final EnumheadContext enumhead() throws RecognitionException {
		EnumheadContext _localctx = new EnumheadContext(_ctx, getState());
		enterRule(_localctx, 180, RULE_enumhead);
		int _la;
		try {
			setState(1489);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1470);
				enumkey();
				setState(1472);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1471);
					attributespecifierseq(0);
					}
				}

				setState(1475);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Identifier) {
					{
					setState(1474);
					match(Identifier);
					}
				}

				setState(1478);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Colon) {
					{
					setState(1477);
					enumbase();
					}
				}

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1480);
				enumkey();
				setState(1482);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1481);
					attributespecifierseq(0);
					}
				}

				setState(1484);
				nestednamespecifier(0);
				setState(1485);
				match(Identifier);
				setState(1487);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Colon) {
					{
					setState(1486);
					enumbase();
					}
				}

				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OpaqueenumdeclarationContext extends ParserRuleContext {
		public EnumkeyContext enumkey() {
			return getRuleContext(EnumkeyContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public EnumbaseContext enumbase() {
			return getRuleContext(EnumbaseContext.class,0);
		}
		public OpaqueenumdeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opaqueenumdeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOpaqueenumdeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOpaqueenumdeclaration(this);
		}
	}

	public final OpaqueenumdeclarationContext opaqueenumdeclaration() throws RecognitionException {
		OpaqueenumdeclarationContext _localctx = new OpaqueenumdeclarationContext(_ctx, getState());
		enterRule(_localctx, 182, RULE_opaqueenumdeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1491);
			enumkey();
			setState(1493);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Alignas || _la==LeftBracket) {
				{
				setState(1492);
				attributespecifierseq(0);
				}
			}

			setState(1495);
			match(Identifier);
			setState(1497);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Colon) {
				{
				setState(1496);
				enumbase();
				}
			}

			setState(1499);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumkeyContext extends ParserRuleContext {
		public TerminalNode Enum() { return getToken(CPP14Parser.Enum, 0); }
		public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); }
		public TerminalNode Struct() { return getToken(CPP14Parser.Struct, 0); }
		public EnumkeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumkey; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumkey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumkey(this);
		}
	}

	public final EnumkeyContext enumkey() throws RecognitionException {
		EnumkeyContext _localctx = new EnumkeyContext(_ctx, getState());
		enterRule(_localctx, 184, RULE_enumkey);
		try {
			setState(1506);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1501);
				match(Enum);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1502);
				match(Enum);
				setState(1503);
				match(Class);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1504);
				match(Enum);
				setState(1505);
				match(Struct);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumbaseContext extends ParserRuleContext {
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public TypespecifierseqContext typespecifierseq() {
			return getRuleContext(TypespecifierseqContext.class,0);
		}
		public EnumbaseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumbase; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumbase(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumbase(this);
		}
	}

	public final EnumbaseContext enumbase() throws RecognitionException {
		EnumbaseContext _localctx = new EnumbaseContext(_ctx, getState());
		enterRule(_localctx, 186, RULE_enumbase);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1508);
			match(Colon);
			setState(1509);
			typespecifierseq();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumeratorlistContext extends ParserRuleContext {
		public EnumeratordefinitionContext enumeratordefinition() {
			return getRuleContext(EnumeratordefinitionContext.class,0);
		}
		public EnumeratorlistContext enumeratorlist() {
			return getRuleContext(EnumeratorlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public EnumeratorlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumeratorlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumeratorlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumeratorlist(this);
		}
	}

	public final EnumeratorlistContext enumeratorlist() throws RecognitionException {
		return enumeratorlist(0);
	}

	private EnumeratorlistContext enumeratorlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		EnumeratorlistContext _localctx = new EnumeratorlistContext(_ctx, _parentState);
		EnumeratorlistContext _prevctx = _localctx;
		int _startState = 188;
		enterRecursionRule(_localctx, 188, RULE_enumeratorlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1512);
			enumeratordefinition();
			}
			_ctx.stop = _input.LT(-1);
			setState(1519);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new EnumeratorlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_enumeratorlist);
					setState(1514);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1515);
					match(Comma);
					setState(1516);
					enumeratordefinition();
					}
					} 
				}
				setState(1521);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumeratordefinitionContext extends ParserRuleContext {
		public EnumeratorContext enumerator() {
			return getRuleContext(EnumeratorContext.class,0);
		}
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public EnumeratordefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumeratordefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumeratordefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumeratordefinition(this);
		}
	}

	public final EnumeratordefinitionContext enumeratordefinition() throws RecognitionException {
		EnumeratordefinitionContext _localctx = new EnumeratordefinitionContext(_ctx, getState());
		enterRule(_localctx, 190, RULE_enumeratordefinition);
		try {
			setState(1527);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1522);
				enumerator();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1523);
				enumerator();
				setState(1524);
				match(Assign);
				setState(1525);
				constantexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumeratorContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public EnumeratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumerator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumerator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumerator(this);
		}
	}

	public final EnumeratorContext enumerator() throws RecognitionException {
		EnumeratorContext _localctx = new EnumeratorContext(_ctx, getState());
		enterRule(_localctx, 192, RULE_enumerator);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1529);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NamespacenameContext extends ParserRuleContext {
		public OriginalnamespacenameContext originalnamespacename() {
			return getRuleContext(OriginalnamespacenameContext.class,0);
		}
		public NamespacealiasContext namespacealias() {
			return getRuleContext(NamespacealiasContext.class,0);
		}
		public NamespacenameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namespacename; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacename(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacename(this);
		}
	}

	public final NamespacenameContext namespacename() throws RecognitionException {
		NamespacenameContext _localctx = new NamespacenameContext(_ctx, getState());
		enterRule(_localctx, 194, RULE_namespacename);
		try {
			setState(1533);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1531);
				originalnamespacename();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1532);
				namespacealias();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OriginalnamespacenameContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public OriginalnamespacenameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_originalnamespacename; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOriginalnamespacename(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOriginalnamespacename(this);
		}
	}

	public final OriginalnamespacenameContext originalnamespacename() throws RecognitionException {
		OriginalnamespacenameContext _localctx = new OriginalnamespacenameContext(_ctx, getState());
		enterRule(_localctx, 196, RULE_originalnamespacename);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1535);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NamespacedefinitionContext extends ParserRuleContext {
		public NamednamespacedefinitionContext namednamespacedefinition() {
			return getRuleContext(NamednamespacedefinitionContext.class,0);
		}
		public UnnamednamespacedefinitionContext unnamednamespacedefinition() {
			return getRuleContext(UnnamednamespacedefinitionContext.class,0);
		}
		public NamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namespacedefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacedefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacedefinition(this);
		}
	}

	public final NamespacedefinitionContext namespacedefinition() throws RecognitionException {
		NamespacedefinitionContext _localctx = new NamespacedefinitionContext(_ctx, getState());
		enterRule(_localctx, 198, RULE_namespacedefinition);
		try {
			setState(1539);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1537);
				namednamespacedefinition();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1538);
				unnamednamespacedefinition();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NamednamespacedefinitionContext extends ParserRuleContext {
		public OriginalnamespacedefinitionContext originalnamespacedefinition() {
			return getRuleContext(OriginalnamespacedefinitionContext.class,0);
		}
		public ExtensionnamespacedefinitionContext extensionnamespacedefinition() {
			return getRuleContext(ExtensionnamespacedefinitionContext.class,0);
		}
		public NamednamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namednamespacedefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamednamespacedefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamednamespacedefinition(this);
		}
	}

	public final NamednamespacedefinitionContext namednamespacedefinition() throws RecognitionException {
		NamednamespacedefinitionContext _localctx = new NamednamespacedefinitionContext(_ctx, getState());
		enterRule(_localctx, 200, RULE_namednamespacedefinition);
		try {
			setState(1543);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1541);
				originalnamespacedefinition();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1542);
				extensionnamespacedefinition();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OriginalnamespacedefinitionContext extends ParserRuleContext {
		public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public NamespacebodyContext namespacebody() {
			return getRuleContext(NamespacebodyContext.class,0);
		}
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
		public OriginalnamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_originalnamespacedefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOriginalnamespacedefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOriginalnamespacedefinition(this);
		}
	}

	public final OriginalnamespacedefinitionContext originalnamespacedefinition() throws RecognitionException {
		OriginalnamespacedefinitionContext _localctx = new OriginalnamespacedefinitionContext(_ctx, getState());
		enterRule(_localctx, 202, RULE_originalnamespacedefinition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1546);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Inline) {
				{
				setState(1545);
				match(Inline);
				}
			}

			setState(1548);
			match(Namespace);
			setState(1549);
			match(Identifier);
			setState(1550);
			match(LeftBrace);
			setState(1551);
			namespacebody();
			setState(1552);
			match(RightBrace);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExtensionnamespacedefinitionContext extends ParserRuleContext {
		public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
		public OriginalnamespacenameContext originalnamespacename() {
			return getRuleContext(OriginalnamespacenameContext.class,0);
		}
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public NamespacebodyContext namespacebody() {
			return getRuleContext(NamespacebodyContext.class,0);
		}
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
		public ExtensionnamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_extensionnamespacedefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExtensionnamespacedefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExtensionnamespacedefinition(this);
		}
	}

	public final ExtensionnamespacedefinitionContext extensionnamespacedefinition() throws RecognitionException {
		ExtensionnamespacedefinitionContext _localctx = new ExtensionnamespacedefinitionContext(_ctx, getState());
		enterRule(_localctx, 204, RULE_extensionnamespacedefinition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1555);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Inline) {
				{
				setState(1554);
				match(Inline);
				}
			}

			setState(1557);
			match(Namespace);
			setState(1558);
			originalnamespacename();
			setState(1559);
			match(LeftBrace);
			setState(1560);
			namespacebody();
			setState(1561);
			match(RightBrace);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UnnamednamespacedefinitionContext extends ParserRuleContext {
		public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public NamespacebodyContext namespacebody() {
			return getRuleContext(NamespacebodyContext.class,0);
		}
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
		public UnnamednamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unnamednamespacedefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnnamednamespacedefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnnamednamespacedefinition(this);
		}
	}

	public final UnnamednamespacedefinitionContext unnamednamespacedefinition() throws RecognitionException {
		UnnamednamespacedefinitionContext _localctx = new UnnamednamespacedefinitionContext(_ctx, getState());
		enterRule(_localctx, 206, RULE_unnamednamespacedefinition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1564);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Inline) {
				{
				setState(1563);
				match(Inline);
				}
			}

			setState(1566);
			match(Namespace);
			setState(1567);
			match(LeftBrace);
			setState(1568);
			namespacebody();
			setState(1569);
			match(RightBrace);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NamespacebodyContext extends ParserRuleContext {
		public DeclarationseqContext declarationseq() {
			return getRuleContext(DeclarationseqContext.class,0);
		}
		public NamespacebodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namespacebody; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacebody(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacebody(this);
		}
	}

	public final NamespacebodyContext namespacebody() throws RecognitionException {
		NamespacebodyContext _localctx = new NamespacebodyContext(_ctx, getState());
		enterRule(_localctx, 208, RULE_namespacebody);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1572);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6253327017007378897L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3674937297293623121L) != 0) {
				{
				setState(1571);
				declarationseq(0);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NamespacealiasContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public NamespacealiasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namespacealias; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacealias(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacealias(this);
		}
	}

	public final NamespacealiasContext namespacealias() throws RecognitionException {
		NamespacealiasContext _localctx = new NamespacealiasContext(_ctx, getState());
		enterRule(_localctx, 210, RULE_namespacealias);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1574);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NamespacealiasdefinitionContext extends ParserRuleContext {
		public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public QualifiednamespacespecifierContext qualifiednamespacespecifier() {
			return getRuleContext(QualifiednamespacespecifierContext.class,0);
		}
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public NamespacealiasdefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namespacealiasdefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacealiasdefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacealiasdefinition(this);
		}
	}

	public final NamespacealiasdefinitionContext namespacealiasdefinition() throws RecognitionException {
		NamespacealiasdefinitionContext _localctx = new NamespacealiasdefinitionContext(_ctx, getState());
		enterRule(_localctx, 212, RULE_namespacealiasdefinition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1576);
			match(Namespace);
			setState(1577);
			match(Identifier);
			setState(1578);
			match(Assign);
			setState(1579);
			qualifiednamespacespecifier();
			setState(1580);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class QualifiednamespacespecifierContext extends ParserRuleContext {
		public NamespacenameContext namespacename() {
			return getRuleContext(NamespacenameContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public QualifiednamespacespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_qualifiednamespacespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterQualifiednamespacespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitQualifiednamespacespecifier(this);
		}
	}

	public final QualifiednamespacespecifierContext qualifiednamespacespecifier() throws RecognitionException {
		QualifiednamespacespecifierContext _localctx = new QualifiednamespacespecifierContext(_ctx, getState());
		enterRule(_localctx, 214, RULE_qualifiednamespacespecifier);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1583);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
			case 1:
				{
				setState(1582);
				nestednamespecifier(0);
				}
				break;
			}
			setState(1585);
			namespacename();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UsingdeclarationContext extends ParserRuleContext {
		public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); }
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public UnqualifiedidContext unqualifiedid() {
			return getRuleContext(UnqualifiedidContext.class,0);
		}
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public TerminalNode Typename_() { return getToken(CPP14Parser.Typename_, 0); }
		public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); }
		public UsingdeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usingdeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUsingdeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUsingdeclaration(this);
		}
	}

	public final UsingdeclarationContext usingdeclaration() throws RecognitionException {
		UsingdeclarationContext _localctx = new UsingdeclarationContext(_ctx, getState());
		enterRule(_localctx, 216, RULE_usingdeclaration);
		int _la;
		try {
			setState(1600);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1587);
				match(Using);
				setState(1589);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Typename_) {
					{
					setState(1588);
					match(Typename_);
					}
				}

				setState(1591);
				nestednamespecifier(0);
				setState(1592);
				unqualifiedid();
				setState(1593);
				match(Semi);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1595);
				match(Using);
				setState(1596);
				match(Doublecolon);
				setState(1597);
				unqualifiedid();
				setState(1598);
				match(Semi);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UsingdirectiveContext extends ParserRuleContext {
		public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); }
		public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
		public NamespacenameContext namespacename() {
			return getRuleContext(NamespacenameContext.class,0);
		}
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public UsingdirectiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usingdirective; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUsingdirective(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUsingdirective(this);
		}
	}

	public final UsingdirectiveContext usingdirective() throws RecognitionException {
		UsingdirectiveContext _localctx = new UsingdirectiveContext(_ctx, getState());
		enterRule(_localctx, 218, RULE_usingdirective);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1603);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Alignas || _la==LeftBracket) {
				{
				setState(1602);
				attributespecifierseq(0);
				}
			}

			setState(1605);
			match(Using);
			setState(1606);
			match(Namespace);
			setState(1608);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
			case 1:
				{
				setState(1607);
				nestednamespecifier(0);
				}
				break;
			}
			setState(1610);
			namespacename();
			setState(1611);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AsmdefinitionContext extends ParserRuleContext {
		public TerminalNode Asm() { return getToken(CPP14Parser.Asm, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public AsmdefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_asmdefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAsmdefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAsmdefinition(this);
		}
	}

	public final AsmdefinitionContext asmdefinition() throws RecognitionException {
		AsmdefinitionContext _localctx = new AsmdefinitionContext(_ctx, getState());
		enterRule(_localctx, 220, RULE_asmdefinition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1613);
			match(Asm);
			setState(1614);
			match(LeftParen);
			setState(1615);
			match(Stringliteral);
			setState(1616);
			match(RightParen);
			setState(1617);
			match(Semi);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LinkagespecificationContext extends ParserRuleContext {
		public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); }
		public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public DeclarationseqContext declarationseq() {
			return getRuleContext(DeclarationseqContext.class,0);
		}
		public DeclarationContext declaration() {
			return getRuleContext(DeclarationContext.class,0);
		}
		public LinkagespecificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_linkagespecification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLinkagespecification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLinkagespecification(this);
		}
	}

	public final LinkagespecificationContext linkagespecification() throws RecognitionException {
		LinkagespecificationContext _localctx = new LinkagespecificationContext(_ctx, getState());
		enterRule(_localctx, 222, RULE_linkagespecification);
		int _la;
		try {
			setState(1629);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1619);
				match(Extern);
				setState(1620);
				match(Stringliteral);
				setState(1621);
				match(LeftBrace);
				setState(1623);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6253327017007378897L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3674937297293623121L) != 0) {
					{
					setState(1622);
					declarationseq(0);
					}
				}

				setState(1625);
				match(RightBrace);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1626);
				match(Extern);
				setState(1627);
				match(Stringliteral);
				setState(1628);
				declaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributespecifierseqContext extends ParserRuleContext {
		public AttributespecifierContext attributespecifier() {
			return getRuleContext(AttributespecifierContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public AttributespecifierseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributespecifierseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributespecifierseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributespecifierseq(this);
		}
	}

	public final AttributespecifierseqContext attributespecifierseq() throws RecognitionException {
		return attributespecifierseq(0);
	}

	private AttributespecifierseqContext attributespecifierseq(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		AttributespecifierseqContext _localctx = new AttributespecifierseqContext(_ctx, _parentState);
		AttributespecifierseqContext _prevctx = _localctx;
		int _startState = 224;
		enterRecursionRule(_localctx, 224, RULE_attributespecifierseq, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1632);
			attributespecifier();
			}
			_ctx.stop = _input.LT(-1);
			setState(1638);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,163,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new AttributespecifierseqContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_attributespecifierseq);
					setState(1634);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1635);
					attributespecifier();
					}
					} 
				}
				setState(1640);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,163,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributespecifierContext extends ParserRuleContext {
		public List<TerminalNode> LeftBracket() { return getTokens(CPP14Parser.LeftBracket); }
		public TerminalNode LeftBracket(int i) {
			return getToken(CPP14Parser.LeftBracket, i);
		}
		public AttributelistContext attributelist() {
			return getRuleContext(AttributelistContext.class,0);
		}
		public List<TerminalNode> RightBracket() { return getTokens(CPP14Parser.RightBracket); }
		public TerminalNode RightBracket(int i) {
			return getToken(CPP14Parser.RightBracket, i);
		}
		public AlignmentspecifierContext alignmentspecifier() {
			return getRuleContext(AlignmentspecifierContext.class,0);
		}
		public AttributespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributespecifier(this);
		}
	}

	public final AttributespecifierContext attributespecifier() throws RecognitionException {
		AttributespecifierContext _localctx = new AttributespecifierContext(_ctx, getState());
		enterRule(_localctx, 226, RULE_attributespecifier);
		try {
			setState(1648);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LeftBracket:
				enterOuterAlt(_localctx, 1);
				{
				setState(1641);
				match(LeftBracket);
				setState(1642);
				match(LeftBracket);
				setState(1643);
				attributelist(0);
				setState(1644);
				match(RightBracket);
				setState(1645);
				match(RightBracket);
				}
				break;
			case Alignas:
				enterOuterAlt(_localctx, 2);
				{
				setState(1647);
				alignmentspecifier();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AlignmentspecifierContext extends ParserRuleContext {
		public TerminalNode Alignas() { return getToken(CPP14Parser.Alignas, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public AlignmentspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_alignmentspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAlignmentspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAlignmentspecifier(this);
		}
	}

	public final AlignmentspecifierContext alignmentspecifier() throws RecognitionException {
		AlignmentspecifierContext _localctx = new AlignmentspecifierContext(_ctx, getState());
		enterRule(_localctx, 228, RULE_alignmentspecifier);
		int _la;
		try {
			setState(1666);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1650);
				match(Alignas);
				setState(1651);
				match(LeftParen);
				setState(1652);
				thetypeid();
				setState(1654);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Ellipsis) {
					{
					setState(1653);
					match(Ellipsis);
					}
				}

				setState(1656);
				match(RightParen);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1658);
				match(Alignas);
				setState(1659);
				match(LeftParen);
				setState(1660);
				constantexpression();
				setState(1662);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Ellipsis) {
					{
					setState(1661);
					match(Ellipsis);
					}
				}

				setState(1664);
				match(RightParen);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributelistContext extends ParserRuleContext {
		public AttributeContext attribute() {
			return getRuleContext(AttributeContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public AttributelistContext attributelist() {
			return getRuleContext(AttributelistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public AttributelistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributelist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributelist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributelist(this);
		}
	}

	public final AttributelistContext attributelist() throws RecognitionException {
		return attributelist(0);
	}

	private AttributelistContext attributelist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		AttributelistContext _localctx = new AttributelistContext(_ctx, _parentState);
		AttributelistContext _prevctx = _localctx;
		int _startState = 230;
		enterRecursionRule(_localctx, 230, RULE_attributelist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1675);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
			case 1:
				{
				setState(1670);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
				case 1:
					{
					setState(1669);
					attribute();
					}
					break;
				}
				}
				break;
			case 2:
				{
				setState(1672);
				attribute();
				setState(1673);
				match(Ellipsis);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(1689);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,172,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(1687);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
					case 1:
						{
						_localctx = new AttributelistContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_attributelist);
						setState(1677);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(1678);
						match(Comma);
						setState(1680);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
						case 1:
							{
							setState(1679);
							attribute();
							}
							break;
						}
						}
						break;
					case 2:
						{
						_localctx = new AttributelistContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_attributelist);
						setState(1682);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(1683);
						match(Comma);
						setState(1684);
						attribute();
						setState(1685);
						match(Ellipsis);
						}
						break;
					}
					} 
				}
				setState(1691);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,172,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeContext extends ParserRuleContext {
		public AttributetokenContext attributetoken() {
			return getRuleContext(AttributetokenContext.class,0);
		}
		public AttributeargumentclauseContext attributeargumentclause() {
			return getRuleContext(AttributeargumentclauseContext.class,0);
		}
		public AttributeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attribute; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttribute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttribute(this);
		}
	}

	public final AttributeContext attribute() throws RecognitionException {
		AttributeContext _localctx = new AttributeContext(_ctx, getState());
		enterRule(_localctx, 232, RULE_attribute);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1692);
			attributetoken();
			setState(1694);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
			case 1:
				{
				setState(1693);
				attributeargumentclause();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributetokenContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public AttributescopedtokenContext attributescopedtoken() {
			return getRuleContext(AttributescopedtokenContext.class,0);
		}
		public AttributetokenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributetoken; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributetoken(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributetoken(this);
		}
	}

	public final AttributetokenContext attributetoken() throws RecognitionException {
		AttributetokenContext _localctx = new AttributetokenContext(_ctx, getState());
		enterRule(_localctx, 234, RULE_attributetoken);
		try {
			setState(1698);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1696);
				match(Identifier);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1697);
				attributescopedtoken();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributescopedtokenContext extends ParserRuleContext {
		public AttributenamespaceContext attributenamespace() {
			return getRuleContext(AttributenamespaceContext.class,0);
		}
		public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public AttributescopedtokenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributescopedtoken; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributescopedtoken(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributescopedtoken(this);
		}
	}

	public final AttributescopedtokenContext attributescopedtoken() throws RecognitionException {
		AttributescopedtokenContext _localctx = new AttributescopedtokenContext(_ctx, getState());
		enterRule(_localctx, 236, RULE_attributescopedtoken);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1700);
			attributenamespace();
			setState(1701);
			match(Doublecolon);
			setState(1702);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributenamespaceContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public AttributenamespaceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributenamespace; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributenamespace(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributenamespace(this);
		}
	}

	public final AttributenamespaceContext attributenamespace() throws RecognitionException {
		AttributenamespaceContext _localctx = new AttributenamespaceContext(_ctx, getState());
		enterRule(_localctx, 238, RULE_attributenamespace);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1704);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeargumentclauseContext extends ParserRuleContext {
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public BalancedtokenseqContext balancedtokenseq() {
			return getRuleContext(BalancedtokenseqContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public AttributeargumentclauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributeargumentclause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributeargumentclause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributeargumentclause(this);
		}
	}

	public final AttributeargumentclauseContext attributeargumentclause() throws RecognitionException {
		AttributeargumentclauseContext _localctx = new AttributeargumentclauseContext(_ctx, getState());
		enterRule(_localctx, 240, RULE_attributeargumentclause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1706);
			match(LeftParen);
			setState(1707);
			balancedtokenseq(0);
			setState(1708);
			match(RightParen);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BalancedtokenseqContext extends ParserRuleContext {
		public BalancedtokenContext balancedtoken() {
			return getRuleContext(BalancedtokenContext.class,0);
		}
		public BalancedtokenseqContext balancedtokenseq() {
			return getRuleContext(BalancedtokenseqContext.class,0);
		}
		public BalancedtokenseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_balancedtokenseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBalancedtokenseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBalancedtokenseq(this);
		}
	}

	public final BalancedtokenseqContext balancedtokenseq() throws RecognitionException {
		return balancedtokenseq(0);
	}

	private BalancedtokenseqContext balancedtokenseq(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		BalancedtokenseqContext _localctx = new BalancedtokenseqContext(_ctx, _parentState);
		BalancedtokenseqContext _prevctx = _localctx;
		int _startState = 242;
		enterRecursionRule(_localctx, 242, RULE_balancedtokenseq, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1712);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
			case 1:
				{
				setState(1711);
				balancedtoken();
				}
				break;
			}
			}
			_ctx.stop = _input.LT(-1);
			setState(1718);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,176,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new BalancedtokenseqContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_balancedtokenseq);
					setState(1714);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1715);
					balancedtoken();
					}
					} 
				}
				setState(1720);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,176,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BalancedtokenContext extends ParserRuleContext {
		public List<TerminalNode> LeftParen() { return getTokens(CPP14Parser.LeftParen); }
		public TerminalNode LeftParen(int i) {
			return getToken(CPP14Parser.LeftParen, i);
		}
		public BalancedtokenseqContext balancedtokenseq() {
			return getRuleContext(BalancedtokenseqContext.class,0);
		}
		public List<TerminalNode> RightParen() { return getTokens(CPP14Parser.RightParen); }
		public TerminalNode RightParen(int i) {
			return getToken(CPP14Parser.RightParen, i);
		}
		public List<TerminalNode> LeftBracket() { return getTokens(CPP14Parser.LeftBracket); }
		public TerminalNode LeftBracket(int i) {
			return getToken(CPP14Parser.LeftBracket, i);
		}
		public List<TerminalNode> RightBracket() { return getTokens(CPP14Parser.RightBracket); }
		public TerminalNode RightBracket(int i) {
			return getToken(CPP14Parser.RightBracket, i);
		}
		public List<TerminalNode> LeftBrace() { return getTokens(CPP14Parser.LeftBrace); }
		public TerminalNode LeftBrace(int i) {
			return getToken(CPP14Parser.LeftBrace, i);
		}
		public List<TerminalNode> RightBrace() { return getTokens(CPP14Parser.RightBrace); }
		public TerminalNode RightBrace(int i) {
			return getToken(CPP14Parser.RightBrace, i);
		}
		public BalancedtokenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_balancedtoken; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBalancedtoken(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBalancedtoken(this);
		}
	}

	public final BalancedtokenContext balancedtoken() throws RecognitionException {
		BalancedtokenContext _localctx = new BalancedtokenContext(_ctx, getState());
		enterRule(_localctx, 244, RULE_balancedtoken);
		int _la;
		try {
			int _alt;
			setState(1738);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LeftParen:
				enterOuterAlt(_localctx, 1);
				{
				setState(1721);
				match(LeftParen);
				setState(1722);
				balancedtokenseq(0);
				setState(1723);
				match(RightParen);
				}
				break;
			case LeftBracket:
				enterOuterAlt(_localctx, 2);
				{
				setState(1725);
				match(LeftBracket);
				setState(1726);
				balancedtokenseq(0);
				setState(1727);
				match(RightBracket);
				}
				break;
			case LeftBrace:
				enterOuterAlt(_localctx, 3);
				{
				setState(1729);
				match(LeftBrace);
				setState(1730);
				balancedtokenseq(0);
				setState(1731);
				match(RightBrace);
				}
				break;
			case T__0:
			case T__1:
			case T__2:
			case T__3:
			case T__4:
			case T__5:
			case Noncontenctbrace:
			case Alignas:
			case Alignof:
			case Asm:
			case Auto:
			case Bool:
			case Break:
			case Case:
			case Catch:
			case Char:
			case Char16:
			case Char32:
			case Class:
			case Const:
			case Constexpr:
			case Const_cast:
			case Continue:
			case Decltype:
			case Default:
			case Delete:
			case Do:
			case Double:
			case Dynamic_cast:
			case Else:
			case Enum:
			case Explicit:
			case Export:
			case Extern:
			case False:
			case Final:
			case Float:
			case For:
			case Friend:
			case Goto:
			case If:
			case Inline:
			case Int:
			case Long:
			case Mutable:
			case Namespace:
			case New:
			case Noexcept:
			case Nullptr:
			case Operator:
			case Override:
			case Private:
			case Protected:
			case Public:
			case Register:
			case Reinterpret_cast:
			case Return:
			case Short:
			case Signed:
			case Sizeof:
			case Static:
			case Static_assert:
			case Static_cast:
			case Struct:
			case Switch:
			case Template:
			case This:
			case Thread_local:
			case Throw:
			case True:
			case Try:
			case Typedef:
			case Typeid_:
			case Typename_:
			case Union:
			case Unsigned:
			case Using:
			case Virtual:
			case Void:
			case Volatile:
			case Wchar:
			case While:
			case Restrict:
			case Plus:
			case Minus:
			case Star:
			case Div:
			case Mod:
			case Caret:
			case And:
			case Or:
			case Tilde:
			case Not:
			case Assign:
			case Less:
			case Greater:
			case PlusAssign:
			case MinusAssign:
			case StarAssign:
			case DivAssign:
			case ModAssign:
			case XorAssign:
			case AndAssign:
			case OrAssign:
			case Equal:
			case NotEqual:
			case LessEqual:
			case GreaterEqual:
			case AndAnd:
			case OrOr:
			case PlusPlus:
			case MinusMinus:
			case Comma:
			case ArrowStar:
			case Arrow:
			case Question:
			case Colon:
			case Doublecolon:
			case Semi:
			case Dot:
			case DotStar:
			case Ellipsis:
			case Identifier:
			case Integerliteral:
			case Decimalliteral:
			case Octalliteral:
			case Hexadecimalliteral:
			case Binaryliteral:
			case Integersuffix:
			case Characterliteral:
			case Floatingliteral:
			case Stringliteral:
			case Userdefinedintegerliteral:
			case Userdefinedfloatingliteral:
			case Userdefinedstringliteral:
			case Userdefinedcharacterliteral:
			case MultiLineMacro:
			case PragmaDirective:
			case IncludeDirective:
			case DefineDirective:
			case IfDirective:
			case ElifDirective:
			case IfndefDirective:
			case EndifDirective:
			case ElseDirective:
			case IllegalDirective:
			case COMMENT:
			case WS:
			case LINE_COMMENT:
				enterOuterAlt(_localctx, 4);
				{
				setState(1734); 
				_errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						setState(1733);
						_la = _input.LA(1);
						if ( _la <= 0 || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 63L) != 0) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(1736); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,177,_ctx);
				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InitdeclaratorlistContext extends ParserRuleContext {
		public InitdeclaratorContext initdeclarator() {
			return getRuleContext(InitdeclaratorContext.class,0);
		}
		public InitdeclaratorlistContext initdeclaratorlist() {
			return getRuleContext(InitdeclaratorlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public InitdeclaratorlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initdeclaratorlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitdeclaratorlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitdeclaratorlist(this);
		}
	}

	public final InitdeclaratorlistContext initdeclaratorlist() throws RecognitionException {
		return initdeclaratorlist(0);
	}

	private InitdeclaratorlistContext initdeclaratorlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		InitdeclaratorlistContext _localctx = new InitdeclaratorlistContext(_ctx, _parentState);
		InitdeclaratorlistContext _prevctx = _localctx;
		int _startState = 246;
		enterRecursionRule(_localctx, 246, RULE_initdeclaratorlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1741);
			initdeclarator();
			}
			_ctx.stop = _input.LT(-1);
			setState(1748);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,179,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new InitdeclaratorlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_initdeclaratorlist);
					setState(1743);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1744);
					match(Comma);
					setState(1745);
					initdeclarator();
					}
					} 
				}
				setState(1750);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,179,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InitdeclaratorContext extends ParserRuleContext {
		public DeclaratorContext declarator() {
			return getRuleContext(DeclaratorContext.class,0);
		}
		public InitializerContext initializer() {
			return getRuleContext(InitializerContext.class,0);
		}
		public InitdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitdeclarator(this);
		}
	}

	public final InitdeclaratorContext initdeclarator() throws RecognitionException {
		InitdeclaratorContext _localctx = new InitdeclaratorContext(_ctx, getState());
		enterRule(_localctx, 248, RULE_initdeclarator);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1751);
			declarator();
			setState(1753);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
			case 1:
				{
				setState(1752);
				initializer();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeclaratorContext extends ParserRuleContext {
		public PtrdeclaratorContext ptrdeclarator() {
			return getRuleContext(PtrdeclaratorContext.class,0);
		}
		public NoptrdeclaratorContext noptrdeclarator() {
			return getRuleContext(NoptrdeclaratorContext.class,0);
		}
		public ParametersandqualifiersContext parametersandqualifiers() {
			return getRuleContext(ParametersandqualifiersContext.class,0);
		}
		public TrailingreturntypeContext trailingreturntype() {
			return getRuleContext(TrailingreturntypeContext.class,0);
		}
		public DeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclarator(this);
		}
	}

	public final DeclaratorContext declarator() throws RecognitionException {
		DeclaratorContext _localctx = new DeclaratorContext(_ctx, getState());
		enterRule(_localctx, 250, RULE_declarator);
		try {
			setState(1760);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1755);
				ptrdeclarator();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1756);
				noptrdeclarator(0);
				setState(1757);
				parametersandqualifiers();
				setState(1758);
				trailingreturntype();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PtrdeclaratorContext extends ParserRuleContext {
		public NoptrdeclaratorContext noptrdeclarator() {
			return getRuleContext(NoptrdeclaratorContext.class,0);
		}
		public PtroperatorContext ptroperator() {
			return getRuleContext(PtroperatorContext.class,0);
		}
		public PtrdeclaratorContext ptrdeclarator() {
			return getRuleContext(PtrdeclaratorContext.class,0);
		}
		public PtrdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ptrdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPtrdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPtrdeclarator(this);
		}
	}

	public final PtrdeclaratorContext ptrdeclarator() throws RecognitionException {
		PtrdeclaratorContext _localctx = new PtrdeclaratorContext(_ctx, getState());
		enterRule(_localctx, 252, RULE_ptrdeclarator);
		try {
			setState(1766);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1762);
				noptrdeclarator(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1763);
				ptroperator();
				setState(1764);
				ptrdeclarator();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NoptrdeclaratorContext extends ParserRuleContext {
		public DeclaratoridContext declaratorid() {
			return getRuleContext(DeclaratoridContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public PtrdeclaratorContext ptrdeclarator() {
			return getRuleContext(PtrdeclaratorContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public NoptrdeclaratorContext noptrdeclarator() {
			return getRuleContext(NoptrdeclaratorContext.class,0);
		}
		public ParametersandqualifiersContext parametersandqualifiers() {
			return getRuleContext(ParametersandqualifiersContext.class,0);
		}
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public NoptrdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_noptrdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrdeclarator(this);
		}
	}

	public final NoptrdeclaratorContext noptrdeclarator() throws RecognitionException {
		return noptrdeclarator(0);
	}

	private NoptrdeclaratorContext noptrdeclarator(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		NoptrdeclaratorContext _localctx = new NoptrdeclaratorContext(_ctx, _parentState);
		NoptrdeclaratorContext _prevctx = _localctx;
		int _startState = 254;
		enterRecursionRule(_localctx, 254, RULE_noptrdeclarator, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1777);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Decltype:
			case Operator:
			case Tilde:
			case Doublecolon:
			case Ellipsis:
			case Identifier:
				{
				setState(1769);
				declaratorid();
				setState(1771);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) {
				case 1:
					{
					setState(1770);
					attributespecifierseq(0);
					}
					break;
				}
				}
				break;
			case LeftParen:
				{
				setState(1773);
				match(LeftParen);
				setState(1774);
				ptrdeclarator();
				setState(1775);
				match(RightParen);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(1792);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,188,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(1790);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,187,_ctx) ) {
					case 1:
						{
						_localctx = new NoptrdeclaratorContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_noptrdeclarator);
						setState(1779);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(1780);
						parametersandqualifiers();
						}
						break;
					case 2:
						{
						_localctx = new NoptrdeclaratorContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_noptrdeclarator);
						setState(1781);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(1782);
						match(LeftBracket);
						setState(1784);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911015753L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
							{
							setState(1783);
							constantexpression();
							}
						}

						setState(1786);
						match(RightBracket);
						setState(1788);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
						case 1:
							{
							setState(1787);
							attributespecifierseq(0);
							}
							break;
						}
						}
						break;
					}
					} 
				}
				setState(1794);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,188,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParametersandqualifiersContext extends ParserRuleContext {
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ParameterdeclarationclauseContext parameterdeclarationclause() {
			return getRuleContext(ParameterdeclarationclauseContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public CvqualifierseqContext cvqualifierseq() {
			return getRuleContext(CvqualifierseqContext.class,0);
		}
		public RefqualifierContext refqualifier() {
			return getRuleContext(RefqualifierContext.class,0);
		}
		public ExceptionspecificationContext exceptionspecification() {
			return getRuleContext(ExceptionspecificationContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public ParametersandqualifiersContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parametersandqualifiers; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParametersandqualifiers(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParametersandqualifiers(this);
		}
	}

	public final ParametersandqualifiersContext parametersandqualifiers() throws RecognitionException {
		ParametersandqualifiersContext _localctx = new ParametersandqualifiersContext(_ctx, getState());
		enterRule(_localctx, 256, RULE_parametersandqualifiers);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1795);
			match(LeftParen);
			setState(1796);
			parameterdeclarationclause();
			setState(1797);
			match(RightParen);
			setState(1799);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
			case 1:
				{
				setState(1798);
				cvqualifierseq();
				}
				break;
			}
			setState(1802);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
			case 1:
				{
				setState(1801);
				refqualifier();
				}
				break;
			}
			setState(1805);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) {
			case 1:
				{
				setState(1804);
				exceptionspecification();
				}
				break;
			}
			setState(1808);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
			case 1:
				{
				setState(1807);
				attributespecifierseq(0);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TrailingreturntypeContext extends ParserRuleContext {
		public TerminalNode Arrow() { return getToken(CPP14Parser.Arrow, 0); }
		public TrailingtypespecifierseqContext trailingtypespecifierseq() {
			return getRuleContext(TrailingtypespecifierseqContext.class,0);
		}
		public AbstractdeclaratorContext abstractdeclarator() {
			return getRuleContext(AbstractdeclaratorContext.class,0);
		}
		public TrailingreturntypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_trailingreturntype; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTrailingreturntype(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTrailingreturntype(this);
		}
	}

	public final TrailingreturntypeContext trailingreturntype() throws RecognitionException {
		TrailingreturntypeContext _localctx = new TrailingreturntypeContext(_ctx, getState());
		enterRule(_localctx, 258, RULE_trailingreturntype);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1810);
			match(Arrow);
			setState(1811);
			trailingtypespecifierseq();
			setState(1813);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
			case 1:
				{
				setState(1812);
				abstractdeclarator();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PtroperatorContext extends ParserRuleContext {
		public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public CvqualifierseqContext cvqualifierseq() {
			return getRuleContext(CvqualifierseqContext.class,0);
		}
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public PtroperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ptroperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPtroperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPtroperator(this);
		}
	}

	public final PtroperatorContext ptroperator() throws RecognitionException {
		PtroperatorContext _localctx = new PtroperatorContext(_ctx, getState());
		enterRule(_localctx, 260, RULE_ptroperator);
		try {
			setState(1838);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Star:
				enterOuterAlt(_localctx, 1);
				{
				setState(1815);
				match(Star);
				setState(1817);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
				case 1:
					{
					setState(1816);
					attributespecifierseq(0);
					}
					break;
				}
				setState(1820);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
				case 1:
					{
					setState(1819);
					cvqualifierseq();
					}
					break;
				}
				}
				break;
			case And:
				enterOuterAlt(_localctx, 2);
				{
				setState(1822);
				match(And);
				setState(1824);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
				case 1:
					{
					setState(1823);
					attributespecifierseq(0);
					}
					break;
				}
				}
				break;
			case T__3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1826);
				match(T__3);
				setState(1828);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) {
				case 1:
					{
					setState(1827);
					attributespecifierseq(0);
					}
					break;
				}
				}
				break;
			case Decltype:
			case Doublecolon:
			case Identifier:
				enterOuterAlt(_localctx, 4);
				{
				setState(1830);
				nestednamespecifier(0);
				setState(1831);
				match(Star);
				setState(1833);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
				case 1:
					{
					setState(1832);
					attributespecifierseq(0);
					}
					break;
				}
				setState(1836);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
				case 1:
					{
					setState(1835);
					cvqualifierseq();
					}
					break;
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CvqualifierseqContext extends ParserRuleContext {
		public CvqualifierContext cvqualifier() {
			return getRuleContext(CvqualifierContext.class,0);
		}
		public CvqualifierseqContext cvqualifierseq() {
			return getRuleContext(CvqualifierseqContext.class,0);
		}
		public CvqualifierseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cvqualifierseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCvqualifierseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCvqualifierseq(this);
		}
	}

	public final CvqualifierseqContext cvqualifierseq() throws RecognitionException {
		CvqualifierseqContext _localctx = new CvqualifierseqContext(_ctx, getState());
		enterRule(_localctx, 262, RULE_cvqualifierseq);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1840);
			cvqualifier();
			setState(1842);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) {
			case 1:
				{
				setState(1841);
				cvqualifierseq();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CvqualifierContext extends ParserRuleContext {
		public TerminalNode Const() { return getToken(CPP14Parser.Const, 0); }
		public TerminalNode Volatile() { return getToken(CPP14Parser.Volatile, 0); }
		public CvqualifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cvqualifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCvqualifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCvqualifier(this);
		}
	}

	public final CvqualifierContext cvqualifier() throws RecognitionException {
		CvqualifierContext _localctx = new CvqualifierContext(_ctx, getState());
		enterRule(_localctx, 264, RULE_cvqualifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1844);
			_la = _input.LA(1);
			if ( !(_la==Const || _la==Volatile) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RefqualifierContext extends ParserRuleContext {
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public RefqualifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_refqualifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRefqualifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRefqualifier(this);
		}
	}

	public final RefqualifierContext refqualifier() throws RecognitionException {
		RefqualifierContext _localctx = new RefqualifierContext(_ctx, getState());
		enterRule(_localctx, 266, RULE_refqualifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1846);
			_la = _input.LA(1);
			if ( !(_la==T__3 || _la==And) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DeclaratoridContext extends ParserRuleContext {
		public IdexpressionContext idexpression() {
			return getRuleContext(IdexpressionContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public DeclaratoridContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declaratorid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclaratorid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclaratorid(this);
		}
	}

	public final DeclaratoridContext declaratorid() throws RecognitionException {
		DeclaratoridContext _localctx = new DeclaratoridContext(_ctx, getState());
		enterRule(_localctx, 268, RULE_declaratorid);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1849);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Ellipsis) {
				{
				setState(1848);
				match(Ellipsis);
				}
			}

			setState(1851);
			idexpression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ThetypeidContext extends ParserRuleContext {
		public TypespecifierseqContext typespecifierseq() {
			return getRuleContext(TypespecifierseqContext.class,0);
		}
		public AbstractdeclaratorContext abstractdeclarator() {
			return getRuleContext(AbstractdeclaratorContext.class,0);
		}
		public ThetypeidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_thetypeid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterThetypeid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitThetypeid(this);
		}
	}

	public final ThetypeidContext thetypeid() throws RecognitionException {
		ThetypeidContext _localctx = new ThetypeidContext(_ctx, getState());
		enterRule(_localctx, 270, RULE_thetypeid);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1853);
			typespecifierseq();
			setState(1855);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
			case 1:
				{
				setState(1854);
				abstractdeclarator();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AbstractdeclaratorContext extends ParserRuleContext {
		public PtrabstractdeclaratorContext ptrabstractdeclarator() {
			return getRuleContext(PtrabstractdeclaratorContext.class,0);
		}
		public ParametersandqualifiersContext parametersandqualifiers() {
			return getRuleContext(ParametersandqualifiersContext.class,0);
		}
		public TrailingreturntypeContext trailingreturntype() {
			return getRuleContext(TrailingreturntypeContext.class,0);
		}
		public NoptrabstractdeclaratorContext noptrabstractdeclarator() {
			return getRuleContext(NoptrabstractdeclaratorContext.class,0);
		}
		public AbstractpackdeclaratorContext abstractpackdeclarator() {
			return getRuleContext(AbstractpackdeclaratorContext.class,0);
		}
		public AbstractdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_abstractdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAbstractdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAbstractdeclarator(this);
		}
	}

	public final AbstractdeclaratorContext abstractdeclarator() throws RecognitionException {
		AbstractdeclaratorContext _localctx = new AbstractdeclaratorContext(_ctx, getState());
		enterRule(_localctx, 272, RULE_abstractdeclarator);
		try {
			setState(1865);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1857);
				ptrabstractdeclarator();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1859);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) {
				case 1:
					{
					setState(1858);
					noptrabstractdeclarator(0);
					}
					break;
				}
				setState(1861);
				parametersandqualifiers();
				setState(1862);
				trailingreturntype();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1864);
				abstractpackdeclarator();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PtrabstractdeclaratorContext extends ParserRuleContext {
		public NoptrabstractdeclaratorContext noptrabstractdeclarator() {
			return getRuleContext(NoptrabstractdeclaratorContext.class,0);
		}
		public PtroperatorContext ptroperator() {
			return getRuleContext(PtroperatorContext.class,0);
		}
		public PtrabstractdeclaratorContext ptrabstractdeclarator() {
			return getRuleContext(PtrabstractdeclaratorContext.class,0);
		}
		public PtrabstractdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ptrabstractdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPtrabstractdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPtrabstractdeclarator(this);
		}
	}

	public final PtrabstractdeclaratorContext ptrabstractdeclarator() throws RecognitionException {
		PtrabstractdeclaratorContext _localctx = new PtrabstractdeclaratorContext(_ctx, getState());
		enterRule(_localctx, 274, RULE_ptrabstractdeclarator);
		try {
			setState(1872);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LeftParen:
			case LeftBracket:
				enterOuterAlt(_localctx, 1);
				{
				setState(1867);
				noptrabstractdeclarator(0);
				}
				break;
			case T__3:
			case Decltype:
			case Star:
			case And:
			case Doublecolon:
			case Identifier:
				enterOuterAlt(_localctx, 2);
				{
				setState(1868);
				ptroperator();
				setState(1870);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
				case 1:
					{
					setState(1869);
					ptrabstractdeclarator();
					}
					break;
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NoptrabstractdeclaratorContext extends ParserRuleContext {
		public ParametersandqualifiersContext parametersandqualifiers() {
			return getRuleContext(ParametersandqualifiersContext.class,0);
		}
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public PtrabstractdeclaratorContext ptrabstractdeclarator() {
			return getRuleContext(PtrabstractdeclaratorContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public NoptrabstractdeclaratorContext noptrabstractdeclarator() {
			return getRuleContext(NoptrabstractdeclaratorContext.class,0);
		}
		public NoptrabstractdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_noptrabstractdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrabstractdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrabstractdeclarator(this);
		}
	}

	public final NoptrabstractdeclaratorContext noptrabstractdeclarator() throws RecognitionException {
		return noptrabstractdeclarator(0);
	}

	private NoptrabstractdeclaratorContext noptrabstractdeclarator(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		NoptrabstractdeclaratorContext _localctx = new NoptrabstractdeclaratorContext(_ctx, _parentState);
		NoptrabstractdeclaratorContext _prevctx = _localctx;
		int _startState = 276;
		enterRecursionRule(_localctx, 276, RULE_noptrabstractdeclarator, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1888);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
			case 1:
				{
				setState(1875);
				parametersandqualifiers();
				}
				break;
			case 2:
				{
				setState(1876);
				match(LeftBracket);
				setState(1878);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911015753L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(1877);
					constantexpression();
					}
				}

				setState(1880);
				match(RightBracket);
				setState(1882);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
				case 1:
					{
					setState(1881);
					attributespecifierseq(0);
					}
					break;
				}
				}
				break;
			case 3:
				{
				setState(1884);
				match(LeftParen);
				setState(1885);
				ptrabstractdeclarator();
				setState(1886);
				match(RightParen);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(1903);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,214,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(1901);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
					case 1:
						{
						_localctx = new NoptrabstractdeclaratorContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractdeclarator);
						setState(1890);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(1891);
						parametersandqualifiers();
						}
						break;
					case 2:
						{
						_localctx = new NoptrabstractdeclaratorContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractdeclarator);
						setState(1892);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(1893);
						match(LeftBracket);
						setState(1895);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911015753L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
							{
							setState(1894);
							constantexpression();
							}
						}

						setState(1897);
						match(RightBracket);
						setState(1899);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,212,_ctx) ) {
						case 1:
							{
							setState(1898);
							attributespecifierseq(0);
							}
							break;
						}
						}
						break;
					}
					} 
				}
				setState(1905);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,214,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AbstractpackdeclaratorContext extends ParserRuleContext {
		public NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator() {
			return getRuleContext(NoptrabstractpackdeclaratorContext.class,0);
		}
		public PtroperatorContext ptroperator() {
			return getRuleContext(PtroperatorContext.class,0);
		}
		public AbstractpackdeclaratorContext abstractpackdeclarator() {
			return getRuleContext(AbstractpackdeclaratorContext.class,0);
		}
		public AbstractpackdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_abstractpackdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAbstractpackdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAbstractpackdeclarator(this);
		}
	}

	public final AbstractpackdeclaratorContext abstractpackdeclarator() throws RecognitionException {
		AbstractpackdeclaratorContext _localctx = new AbstractpackdeclaratorContext(_ctx, getState());
		enterRule(_localctx, 278, RULE_abstractpackdeclarator);
		try {
			setState(1910);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Ellipsis:
				enterOuterAlt(_localctx, 1);
				{
				setState(1906);
				noptrabstractpackdeclarator(0);
				}
				break;
			case T__3:
			case Decltype:
			case Star:
			case And:
			case Doublecolon:
			case Identifier:
				enterOuterAlt(_localctx, 2);
				{
				setState(1907);
				ptroperator();
				setState(1908);
				abstractpackdeclarator();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NoptrabstractpackdeclaratorContext extends ParserRuleContext {
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator() {
			return getRuleContext(NoptrabstractpackdeclaratorContext.class,0);
		}
		public ParametersandqualifiersContext parametersandqualifiers() {
			return getRuleContext(ParametersandqualifiersContext.class,0);
		}
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public NoptrabstractpackdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_noptrabstractpackdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrabstractpackdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrabstractpackdeclarator(this);
		}
	}

	public final NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator() throws RecognitionException {
		return noptrabstractpackdeclarator(0);
	}

	private NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		NoptrabstractpackdeclaratorContext _localctx = new NoptrabstractpackdeclaratorContext(_ctx, _parentState);
		NoptrabstractpackdeclaratorContext _prevctx = _localctx;
		int _startState = 280;
		enterRecursionRule(_localctx, 280, RULE_noptrabstractpackdeclarator, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1913);
			match(Ellipsis);
			}
			_ctx.stop = _input.LT(-1);
			setState(1928);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,219,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(1926);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) {
					case 1:
						{
						_localctx = new NoptrabstractpackdeclaratorContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractpackdeclarator);
						setState(1915);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(1916);
						parametersandqualifiers();
						}
						break;
					case 2:
						{
						_localctx = new NoptrabstractpackdeclaratorContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractpackdeclarator);
						setState(1917);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(1918);
						match(LeftBracket);
						setState(1920);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911015753L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
							{
							setState(1919);
							constantexpression();
							}
						}

						setState(1922);
						match(RightBracket);
						setState(1924);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,217,_ctx) ) {
						case 1:
							{
							setState(1923);
							attributespecifierseq(0);
							}
							break;
						}
						}
						break;
					}
					} 
				}
				setState(1930);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,219,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterdeclarationclauseContext extends ParserRuleContext {
		public ParameterdeclarationlistContext parameterdeclarationlist() {
			return getRuleContext(ParameterdeclarationlistContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public ParameterdeclarationclauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameterdeclarationclause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParameterdeclarationclause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParameterdeclarationclause(this);
		}
	}

	public final ParameterdeclarationclauseContext parameterdeclarationclause() throws RecognitionException {
		ParameterdeclarationclauseContext _localctx = new ParameterdeclarationclauseContext(_ctx, getState());
		enterRule(_localctx, 282, RULE_parameterdeclarationclause);
		int _la;
		try {
			setState(1941);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,222,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1932);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la - 8)) & ~0x3f) == 0 && ((1L << (_la - 8)) & 1525735371735908121L) != 0 || (((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 148618787703243733L) != 0) {
					{
					setState(1931);
					parameterdeclarationlist(0);
					}
				}

				setState(1935);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Ellipsis) {
					{
					setState(1934);
					match(Ellipsis);
					}
				}

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1937);
				parameterdeclarationlist(0);
				setState(1938);
				match(Comma);
				setState(1939);
				match(Ellipsis);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterdeclarationlistContext extends ParserRuleContext {
		public ParameterdeclarationContext parameterdeclaration() {
			return getRuleContext(ParameterdeclarationContext.class,0);
		}
		public ParameterdeclarationlistContext parameterdeclarationlist() {
			return getRuleContext(ParameterdeclarationlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public ParameterdeclarationlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameterdeclarationlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParameterdeclarationlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParameterdeclarationlist(this);
		}
	}

	public final ParameterdeclarationlistContext parameterdeclarationlist() throws RecognitionException {
		return parameterdeclarationlist(0);
	}

	private ParameterdeclarationlistContext parameterdeclarationlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ParameterdeclarationlistContext _localctx = new ParameterdeclarationlistContext(_ctx, _parentState);
		ParameterdeclarationlistContext _prevctx = _localctx;
		int _startState = 284;
		enterRecursionRule(_localctx, 284, RULE_parameterdeclarationlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(1944);
			parameterdeclaration();
			}
			_ctx.stop = _input.LT(-1);
			setState(1951);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,223,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new ParameterdeclarationlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_parameterdeclarationlist);
					setState(1946);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(1947);
					match(Comma);
					setState(1948);
					parameterdeclaration();
					}
					} 
				}
				setState(1953);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,223,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterdeclarationContext extends ParserRuleContext {
		public DeclspecifierseqContext declspecifierseq() {
			return getRuleContext(DeclspecifierseqContext.class,0);
		}
		public DeclaratorContext declarator() {
			return getRuleContext(DeclaratorContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public CvqualifierseqContext cvqualifierseq() {
			return getRuleContext(CvqualifierseqContext.class,0);
		}
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public InitializerclauseContext initializerclause() {
			return getRuleContext(InitializerclauseContext.class,0);
		}
		public AbstractdeclaratorContext abstractdeclarator() {
			return getRuleContext(AbstractdeclaratorContext.class,0);
		}
		public ParameterdeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameterdeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParameterdeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParameterdeclaration(this);
		}
	}

	public final ParameterdeclarationContext parameterdeclaration() throws RecognitionException {
		ParameterdeclarationContext _localctx = new ParameterdeclarationContext(_ctx, getState());
		enterRule(_localctx, 286, RULE_parameterdeclaration);
		int _la;
		try {
			setState(1988);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1955);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1954);
					attributespecifierseq(0);
					}
				}

				setState(1958);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) {
				case 1:
					{
					setState(1957);
					cvqualifierseq();
					}
					break;
				}
				setState(1960);
				declspecifierseq();
				setState(1961);
				declarator();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1964);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1963);
					attributespecifierseq(0);
					}
				}

				setState(1966);
				declspecifierseq();
				setState(1967);
				declarator();
				setState(1968);
				match(Assign);
				setState(1969);
				initializerclause();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1972);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1971);
					attributespecifierseq(0);
					}
				}

				setState(1974);
				declspecifierseq();
				setState(1976);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
				case 1:
					{
					setState(1975);
					abstractdeclarator();
					}
					break;
				}
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1979);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(1978);
					attributespecifierseq(0);
					}
				}

				setState(1981);
				declspecifierseq();
				setState(1983);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__3 || _la==Decltype || (((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 53876069765381L) != 0) {
					{
					setState(1982);
					abstractdeclarator();
					}
				}

				setState(1985);
				match(Assign);
				setState(1986);
				initializerclause();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FunctiondefinitionContext extends ParserRuleContext {
		public DeclaratorContext declarator() {
			return getRuleContext(DeclaratorContext.class,0);
		}
		public FunctionbodyContext functionbody() {
			return getRuleContext(FunctionbodyContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public DeclspecifierseqContext declspecifierseq() {
			return getRuleContext(DeclspecifierseqContext.class,0);
		}
		public VirtspecifierseqContext virtspecifierseq() {
			return getRuleContext(VirtspecifierseqContext.class,0);
		}
		public FunctiondefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functiondefinition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctiondefinition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctiondefinition(this);
		}
	}

	public final FunctiondefinitionContext functiondefinition() throws RecognitionException {
		FunctiondefinitionContext _localctx = new FunctiondefinitionContext(_ctx, getState());
		enterRule(_localctx, 288, RULE_functiondefinition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1991);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Alignas || _la==LeftBracket) {
				{
				setState(1990);
				attributespecifierseq(0);
				}
			}

			setState(1994);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
			case 1:
				{
				setState(1993);
				declspecifierseq();
				}
				break;
			}
			setState(1996);
			declarator();
			setState(1998);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Final || _la==Override) {
				{
				setState(1997);
				virtspecifierseq(0);
				}
			}

			setState(2000);
			functionbody();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FunctionbodyContext extends ParserRuleContext {
		public CompoundstatementContext compoundstatement() {
			return getRuleContext(CompoundstatementContext.class,0);
		}
		public CtorinitializerContext ctorinitializer() {
			return getRuleContext(CtorinitializerContext.class,0);
		}
		public FunctiontryblockContext functiontryblock() {
			return getRuleContext(FunctiontryblockContext.class,0);
		}
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public TerminalNode Default() { return getToken(CPP14Parser.Default, 0); }
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); }
		public FunctionbodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functionbody; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctionbody(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctionbody(this);
		}
	}

	public final FunctionbodyContext functionbody() throws RecognitionException {
		FunctionbodyContext _localctx = new FunctionbodyContext(_ctx, getState());
		enterRule(_localctx, 290, RULE_functionbody);
		int _la;
		try {
			setState(2013);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2003);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Colon) {
					{
					setState(2002);
					ctorinitializer();
					}
				}

				setState(2005);
				compoundstatement();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2006);
				functiontryblock();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2007);
				match(Assign);
				setState(2008);
				match(Default);
				setState(2009);
				match(Semi);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(2010);
				match(Assign);
				setState(2011);
				match(Delete);
				setState(2012);
				match(Semi);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InitializerContext extends ParserRuleContext {
		public BraceorequalinitializerContext braceorequalinitializer() {
			return getRuleContext(BraceorequalinitializerContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ExpressionlistContext expressionlist() {
			return getRuleContext(ExpressionlistContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public InitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitializer(this);
		}
	}

	public final InitializerContext initializer() throws RecognitionException {
		InitializerContext _localctx = new InitializerContext(_ctx, getState());
		enterRule(_localctx, 292, RULE_initializer);
		try {
			setState(2020);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LeftBrace:
			case Assign:
				enterOuterAlt(_localctx, 1);
				{
				setState(2015);
				braceorequalinitializer();
				}
				break;
			case LeftParen:
				enterOuterAlt(_localctx, 2);
				{
				setState(2016);
				match(LeftParen);
				setState(2017);
				expressionlist();
				setState(2018);
				match(RightParen);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BraceorequalinitializerContext extends ParserRuleContext {
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public InitializerclauseContext initializerclause() {
			return getRuleContext(InitializerclauseContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public BraceorequalinitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_braceorequalinitializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBraceorequalinitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBraceorequalinitializer(this);
		}
	}

	public final BraceorequalinitializerContext braceorequalinitializer() throws RecognitionException {
		BraceorequalinitializerContext _localctx = new BraceorequalinitializerContext(_ctx, getState());
		enterRule(_localctx, 294, RULE_braceorequalinitializer);
		try {
			setState(2025);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Assign:
				enterOuterAlt(_localctx, 1);
				{
				setState(2022);
				match(Assign);
				setState(2023);
				initializerclause();
				}
				break;
			case LeftBrace:
				enterOuterAlt(_localctx, 2);
				{
				setState(2024);
				bracedinitlist();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InitializerclauseContext extends ParserRuleContext {
		public AssignmentexpressionContext assignmentexpression() {
			return getRuleContext(AssignmentexpressionContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public InitializerclauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initializerclause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitializerclause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitializerclause(this);
		}
	}

	public final InitializerclauseContext initializerclause() throws RecognitionException {
		InitializerclauseContext _localctx = new InitializerclauseContext(_ctx, getState());
		enterRule(_localctx, 296, RULE_initializerclause);
		try {
			setState(2029);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__0:
			case T__1:
			case Alignof:
			case Auto:
			case Bool:
			case Char:
			case Char16:
			case Char32:
			case Const_cast:
			case Decltype:
			case Delete:
			case Double:
			case Dynamic_cast:
			case False:
			case Float:
			case Int:
			case Long:
			case New:
			case Noexcept:
			case Nullptr:
			case Operator:
			case Reinterpret_cast:
			case Short:
			case Signed:
			case Sizeof:
			case Static_cast:
			case Struct:
			case This:
			case Throw:
			case True:
			case Typedef:
			case Typeid_:
			case Typename_:
			case Unsigned:
			case Void:
			case Wchar:
			case LeftParen:
			case LeftBracket:
			case Plus:
			case Minus:
			case Star:
			case And:
			case Or:
			case Tilde:
			case PlusPlus:
			case MinusMinus:
			case Doublecolon:
			case Identifier:
			case Integerliteral:
			case Characterliteral:
			case Floatingliteral:
			case Stringliteral:
			case Userdefinedintegerliteral:
			case Userdefinedfloatingliteral:
			case Userdefinedstringliteral:
			case Userdefinedcharacterliteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(2027);
				assignmentexpression();
				}
				break;
			case LeftBrace:
				enterOuterAlt(_localctx, 2);
				{
				setState(2028);
				bracedinitlist();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InitializerlistContext extends ParserRuleContext {
		public InitializerclauseContext initializerclause() {
			return getRuleContext(InitializerclauseContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public InitializerlistContext initializerlist() {
			return getRuleContext(InitializerlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public InitializerlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initializerlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitializerlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitializerlist(this);
		}
	}

	public final InitializerlistContext initializerlist() throws RecognitionException {
		return initializerlist(0);
	}

	private InitializerlistContext initializerlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		InitializerlistContext _localctx = new InitializerlistContext(_ctx, _parentState);
		InitializerlistContext _prevctx = _localctx;
		int _startState = 298;
		enterRecursionRule(_localctx, 298, RULE_initializerlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2032);
			initializerclause();
			setState(2034);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,240,_ctx) ) {
			case 1:
				{
				setState(2033);
				match(Ellipsis);
				}
				break;
			}
			}
			_ctx.stop = _input.LT(-1);
			setState(2044);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new InitializerlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_initializerlist);
					setState(2036);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2037);
					match(Comma);
					setState(2038);
					initializerclause();
					setState(2040);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,241,_ctx) ) {
					case 1:
						{
						setState(2039);
						match(Ellipsis);
						}
						break;
					}
					}
					} 
				}
				setState(2046);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BracedinitlistContext extends ParserRuleContext {
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public InitializerlistContext initializerlist() {
			return getRuleContext(InitializerlistContext.class,0);
		}
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public BracedinitlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bracedinitlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBracedinitlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBracedinitlist(this);
		}
	}

	public final BracedinitlistContext bracedinitlist() throws RecognitionException {
		BracedinitlistContext _localctx = new BracedinitlistContext(_ctx, getState());
		enterRule(_localctx, 300, RULE_bracedinitlist);
		int _la;
		try {
			setState(2056);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2047);
				match(LeftBrace);
				setState(2048);
				initializerlist(0);
				setState(2050);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Comma) {
					{
					setState(2049);
					match(Comma);
					}
				}

				setState(2052);
				match(RightBrace);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2054);
				match(LeftBrace);
				setState(2055);
				match(RightBrace);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassnameContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public ClassnameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classname; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassname(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassname(this);
		}
	}

	public final ClassnameContext classname() throws RecognitionException {
		ClassnameContext _localctx = new ClassnameContext(_ctx, getState());
		enterRule(_localctx, 302, RULE_classname);
		try {
			setState(2060);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,245,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2058);
				match(Identifier);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2059);
				simpletemplateid();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypedefspecifierContext extends ParserRuleContext {
		public TypestructheadContext typestructhead() {
			return getRuleContext(TypestructheadContext.class,0);
		}
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public MemberspecificationContext memberspecification() {
			return getRuleContext(MemberspecificationContext.class,0);
		}
		public TypedefnameContext typedefname() {
			return getRuleContext(TypedefnameContext.class,0);
		}
		public TypedefspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typedefspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypedefspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypedefspecifier(this);
		}
	}

	public final TypedefspecifierContext typedefspecifier() throws RecognitionException {
		TypedefspecifierContext _localctx = new TypedefspecifierContext(_ctx, getState());
		enterRule(_localctx, 304, RULE_typedefspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2062);
			typestructhead();
			setState(2063);
			match(LeftBrace);
			setState(2065);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6255292943797842321L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3710966094312587089L) != 0) {
				{
				setState(2064);
				memberspecification();
				}
			}

			setState(2067);
			match(RightBrace);
			setState(2069);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,247,_ctx) ) {
			case 1:
				{
				setState(2068);
				typedefname();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypestructheadContext extends ParserRuleContext {
		public TypestructkeyContext typestructkey() {
			return getRuleContext(TypestructkeyContext.class,0);
		}
		public StructnameContext structname() {
			return getRuleContext(StructnameContext.class,0);
		}
		public TypestructheadContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typestructhead; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypestructhead(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypestructhead(this);
		}
	}

	public final TypestructheadContext typestructhead() throws RecognitionException {
		TypestructheadContext _localctx = new TypestructheadContext(_ctx, getState());
		enterRule(_localctx, 306, RULE_typestructhead);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2071);
			typestructkey();
			setState(2073);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Identifier) {
				{
				setState(2072);
				structname();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InherittypedefspecifierContext extends ParserRuleContext {
		public InheritstructheadContext inheritstructhead() {
			return getRuleContext(InheritstructheadContext.class,0);
		}
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public MemberspecificationContext memberspecification() {
			return getRuleContext(MemberspecificationContext.class,0);
		}
		public TypedefnameContext typedefname() {
			return getRuleContext(TypedefnameContext.class,0);
		}
		public InherittypedefspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inherittypedefspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInherittypedefspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInherittypedefspecifier(this);
		}
	}

	public final InherittypedefspecifierContext inherittypedefspecifier() throws RecognitionException {
		InherittypedefspecifierContext _localctx = new InherittypedefspecifierContext(_ctx, getState());
		enterRule(_localctx, 308, RULE_inherittypedefspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2075);
			inheritstructhead();
			setState(2076);
			match(LeftBrace);
			setState(2078);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6255292943797842321L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3710966094312587089L) != 0) {
				{
				setState(2077);
				memberspecification();
				}
			}

			setState(2080);
			match(RightBrace);
			setState(2082);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,250,_ctx) ) {
			case 1:
				{
				setState(2081);
				typedefname();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InheritstructheadContext extends ParserRuleContext {
		public TypestructkeyContext typestructkey() {
			return getRuleContext(TypestructkeyContext.class,0);
		}
		public BaseclauseContext baseclause() {
			return getRuleContext(BaseclauseContext.class,0);
		}
		public StructnameContext structname() {
			return getRuleContext(StructnameContext.class,0);
		}
		public InheritstructheadContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inheritstructhead; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInheritstructhead(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInheritstructhead(this);
		}
	}

	public final InheritstructheadContext inheritstructhead() throws RecognitionException {
		InheritstructheadContext _localctx = new InheritstructheadContext(_ctx, getState());
		enterRule(_localctx, 310, RULE_inheritstructhead);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2084);
			typestructkey();
			setState(2086);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Identifier) {
				{
				setState(2085);
				structname();
				}
			}

			setState(2088);
			baseclause();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class InheritclassspecifierContext extends ParserRuleContext {
		public ClassheadContext classhead() {
			return getRuleContext(ClassheadContext.class,0);
		}
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public MemberspecificationContext memberspecification() {
			return getRuleContext(MemberspecificationContext.class,0);
		}
		public InheritclassspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inheritclassspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInheritclassspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInheritclassspecifier(this);
		}
	}

	public final InheritclassspecifierContext inheritclassspecifier() throws RecognitionException {
		InheritclassspecifierContext _localctx = new InheritclassspecifierContext(_ctx, getState());
		enterRule(_localctx, 312, RULE_inheritclassspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2090);
			classhead();
			setState(2091);
			match(LeftBrace);
			setState(2093);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6255292943797842321L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3710966094312587089L) != 0) {
				{
				setState(2092);
				memberspecification();
				}
			}

			setState(2095);
			match(RightBrace);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BaseclassspecifierContext extends ParserRuleContext {
		public BaseclassheadContext baseclasshead() {
			return getRuleContext(BaseclassheadContext.class,0);
		}
		public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); }
		public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); }
		public MemberspecificationContext memberspecification() {
			return getRuleContext(MemberspecificationContext.class,0);
		}
		public BaseclassspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_baseclassspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBaseclassspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBaseclassspecifier(this);
		}
	}

	public final BaseclassspecifierContext baseclassspecifier() throws RecognitionException {
		BaseclassspecifierContext _localctx = new BaseclassspecifierContext(_ctx, getState());
		enterRule(_localctx, 314, RULE_baseclassspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2097);
			baseclasshead();
			setState(2098);
			match(LeftBrace);
			setState(2100);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6255292943797842321L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3710966094312587089L) != 0) {
				{
				setState(2099);
				memberspecification();
				}
			}

			setState(2102);
			match(RightBrace);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BaseclassheadContext extends ParserRuleContext {
		public ClasskeyContext classkey() {
			return getRuleContext(ClasskeyContext.class,0);
		}
		public ClassheadnameContext classheadname() {
			return getRuleContext(ClassheadnameContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public ClassvirtspecifierContext classvirtspecifier() {
			return getRuleContext(ClassvirtspecifierContext.class,0);
		}
		public BaseclassheadContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_baseclasshead; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBaseclasshead(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBaseclasshead(this);
		}
	}

	public final BaseclassheadContext baseclasshead() throws RecognitionException {
		BaseclassheadContext _localctx = new BaseclassheadContext(_ctx, getState());
		enterRule(_localctx, 316, RULE_baseclasshead);
		int _la;
		try {
			setState(2116);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,257,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2104);
				classkey();
				setState(2106);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2105);
					attributespecifierseq(0);
					}
				}

				setState(2108);
				classheadname();
				setState(2110);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Final) {
					{
					setState(2109);
					classvirtspecifier();
					}
				}

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2112);
				classkey();
				setState(2114);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2113);
					attributespecifierseq(0);
					}
				}

				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassheadContext extends ParserRuleContext {
		public ClasskeyContext classkey() {
			return getRuleContext(ClasskeyContext.class,0);
		}
		public ClassheadnameContext classheadname() {
			return getRuleContext(ClassheadnameContext.class,0);
		}
		public BaseclauseContext baseclause() {
			return getRuleContext(BaseclauseContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public ClassvirtspecifierContext classvirtspecifier() {
			return getRuleContext(ClassvirtspecifierContext.class,0);
		}
		public ClassheadContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classhead; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClasshead(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClasshead(this);
		}
	}

	public final ClassheadContext classhead() throws RecognitionException {
		ClassheadContext _localctx = new ClassheadContext(_ctx, getState());
		enterRule(_localctx, 318, RULE_classhead);
		int _la;
		try {
			setState(2134);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,261,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2118);
				classkey();
				setState(2120);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2119);
					attributespecifierseq(0);
					}
				}

				setState(2122);
				classheadname();
				setState(2124);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Final) {
					{
					setState(2123);
					classvirtspecifier();
					}
				}

				setState(2126);
				baseclause();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2128);
				classkey();
				setState(2130);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2129);
					attributespecifierseq(0);
					}
				}

				setState(2132);
				baseclause();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassheadnameContext extends ParserRuleContext {
		public ClassnameContext classname() {
			return getRuleContext(ClassnameContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public ClassheadnameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classheadname; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassheadname(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassheadname(this);
		}
	}

	public final ClassheadnameContext classheadname() throws RecognitionException {
		ClassheadnameContext _localctx = new ClassheadnameContext(_ctx, getState());
		enterRule(_localctx, 320, RULE_classheadname);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2137);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) {
			case 1:
				{
				setState(2136);
				nestednamespecifier(0);
				}
				break;
			}
			setState(2139);
			classname();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassvirtspecifierContext extends ParserRuleContext {
		public TerminalNode Final() { return getToken(CPP14Parser.Final, 0); }
		public ClassvirtspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classvirtspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassvirtspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassvirtspecifier(this);
		}
	}

	public final ClassvirtspecifierContext classvirtspecifier() throws RecognitionException {
		ClassvirtspecifierContext _localctx = new ClassvirtspecifierContext(_ctx, getState());
		enterRule(_localctx, 322, RULE_classvirtspecifier);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2141);
			match(Final);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClasskeyContext extends ParserRuleContext {
		public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); }
		public ClasskeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classkey; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClasskey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClasskey(this);
		}
	}

	public final ClasskeyContext classkey() throws RecognitionException {
		ClasskeyContext _localctx = new ClasskeyContext(_ctx, getState());
		enterRule(_localctx, 324, RULE_classkey);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2143);
			match(Class);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypestructkeyContext extends ParserRuleContext {
		public TerminalNode Struct() { return getToken(CPP14Parser.Struct, 0); }
		public TerminalNode Typedef() { return getToken(CPP14Parser.Typedef, 0); }
		public TypestructkeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typestructkey; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypestructkey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypestructkey(this);
		}
	}

	public final TypestructkeyContext typestructkey() throws RecognitionException {
		TypestructkeyContext _localctx = new TypestructkeyContext(_ctx, getState());
		enterRule(_localctx, 326, RULE_typestructkey);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2146);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Typedef) {
				{
				setState(2145);
				match(Typedef);
				}
			}

			setState(2148);
			match(Struct);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MemberspecificationContext extends ParserRuleContext {
		public MemberdeclarationContext memberdeclaration() {
			return getRuleContext(MemberdeclarationContext.class,0);
		}
		public MemberspecificationContext memberspecification() {
			return getRuleContext(MemberspecificationContext.class,0);
		}
		public AccessspecifierContext accessspecifier() {
			return getRuleContext(AccessspecifierContext.class,0);
		}
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public MemberspecificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_memberspecification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberspecification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberspecification(this);
		}
	}

	public final MemberspecificationContext memberspecification() throws RecognitionException {
		MemberspecificationContext _localctx = new MemberspecificationContext(_ctx, getState());
		enterRule(_localctx, 328, RULE_memberspecification);
		int _la;
		try {
			setState(2159);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__3:
			case Alignas:
			case Auto:
			case Bool:
			case Char:
			case Char16:
			case Char32:
			case Class:
			case Const:
			case Constexpr:
			case Decltype:
			case Double:
			case Enum:
			case Explicit:
			case Extern:
			case Float:
			case Friend:
			case Inline:
			case Int:
			case Long:
			case Mutable:
			case Operator:
			case Register:
			case Short:
			case Signed:
			case Static:
			case Static_assert:
			case Struct:
			case Template:
			case Thread_local:
			case Typedef:
			case Typename_:
			case Unsigned:
			case Using:
			case Virtual:
			case Void:
			case Volatile:
			case Wchar:
			case LeftParen:
			case LeftBracket:
			case Star:
			case And:
			case Tilde:
			case Colon:
			case Doublecolon:
			case Semi:
			case Ellipsis:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(2150);
				memberdeclaration();
				setState(2152);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6255292943797842321L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3710966094312587089L) != 0) {
					{
					setState(2151);
					memberspecification();
					}
				}

				}
				break;
			case Private:
			case Protected:
			case Public:
				enterOuterAlt(_localctx, 2);
				{
				setState(2154);
				accessspecifier();
				setState(2155);
				match(Colon);
				setState(2157);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & 6255292943797842321L) != 0 || (((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 3710966094312587089L) != 0) {
					{
					setState(2156);
					memberspecification();
					}
				}

				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MemberdeclarationContext extends ParserRuleContext {
		public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public DeclspecifierseqContext declspecifierseq() {
			return getRuleContext(DeclspecifierseqContext.class,0);
		}
		public RestricttypelistContext restricttypelist() {
			return getRuleContext(RestricttypelistContext.class,0);
		}
		public MemberdeclaratorlistContext memberdeclaratorlist() {
			return getRuleContext(MemberdeclaratorlistContext.class,0);
		}
		public FunctiondefinitionContext functiondefinition() {
			return getRuleContext(FunctiondefinitionContext.class,0);
		}
		public UsingdeclarationContext usingdeclaration() {
			return getRuleContext(UsingdeclarationContext.class,0);
		}
		public Static_assertdeclarationContext static_assertdeclaration() {
			return getRuleContext(Static_assertdeclarationContext.class,0);
		}
		public TemplatedeclarationContext templatedeclaration() {
			return getRuleContext(TemplatedeclarationContext.class,0);
		}
		public AliasdeclarationContext aliasdeclaration() {
			return getRuleContext(AliasdeclarationContext.class,0);
		}
		public EmptydeclarationContext emptydeclaration() {
			return getRuleContext(EmptydeclarationContext.class,0);
		}
		public MemberdeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_memberdeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberdeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberdeclaration(this);
		}
	}

	public final MemberdeclarationContext memberdeclaration() throws RecognitionException {
		MemberdeclarationContext _localctx = new MemberdeclarationContext(_ctx, getState());
		enterRule(_localctx, 330, RULE_memberdeclaration);
		int _la;
		try {
			setState(2180);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,271,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2162);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,267,_ctx) ) {
				case 1:
					{
					setState(2161);
					attributespecifierseq(0);
					}
					break;
				}
				setState(2165);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,268,_ctx) ) {
				case 1:
					{
					setState(2164);
					declspecifierseq();
					}
					break;
				}
				setState(2168);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,269,_ctx) ) {
				case 1:
					{
					setState(2167);
					restricttypelist(0);
					}
					break;
				}
				setState(2171);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & 1125899923620112L) != 0 || (((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 54425825595653L) != 0) {
					{
					setState(2170);
					memberdeclaratorlist(0);
					}
				}

				setState(2173);
				match(Semi);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2174);
				functiondefinition();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2175);
				usingdeclaration();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(2176);
				static_assertdeclaration();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(2177);
				templatedeclaration();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(2178);
				aliasdeclaration();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(2179);
				emptydeclaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MemberdeclaratorlistContext extends ParserRuleContext {
		public MemberdeclaratorContext memberdeclarator() {
			return getRuleContext(MemberdeclaratorContext.class,0);
		}
		public MemberdeclaratorlistContext memberdeclaratorlist() {
			return getRuleContext(MemberdeclaratorlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public MemberdeclaratorlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_memberdeclaratorlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberdeclaratorlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberdeclaratorlist(this);
		}
	}

	public final MemberdeclaratorlistContext memberdeclaratorlist() throws RecognitionException {
		return memberdeclaratorlist(0);
	}

	private MemberdeclaratorlistContext memberdeclaratorlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		MemberdeclaratorlistContext _localctx = new MemberdeclaratorlistContext(_ctx, _parentState);
		MemberdeclaratorlistContext _prevctx = _localctx;
		int _startState = 332;
		enterRecursionRule(_localctx, 332, RULE_memberdeclaratorlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2183);
			memberdeclarator();
			}
			_ctx.stop = _input.LT(-1);
			setState(2190);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,272,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new MemberdeclaratorlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_memberdeclaratorlist);
					setState(2185);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2186);
					match(Comma);
					setState(2187);
					memberdeclarator();
					}
					} 
				}
				setState(2192);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,272,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MemberdeclaratorContext extends ParserRuleContext {
		public DeclaratorContext declarator() {
			return getRuleContext(DeclaratorContext.class,0);
		}
		public VirtspecifierseqContext virtspecifierseq() {
			return getRuleContext(VirtspecifierseqContext.class,0);
		}
		public PurespecifierContext purespecifier() {
			return getRuleContext(PurespecifierContext.class,0);
		}
		public BraceorequalinitializerContext braceorequalinitializer() {
			return getRuleContext(BraceorequalinitializerContext.class,0);
		}
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public MemberdeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_memberdeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberdeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberdeclarator(this);
		}
	}

	public final MemberdeclaratorContext memberdeclarator() throws RecognitionException {
		MemberdeclaratorContext _localctx = new MemberdeclaratorContext(_ctx, getState());
		enterRule(_localctx, 334, RULE_memberdeclarator);
		int _la;
		try {
			setState(2212);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2193);
				declarator();
				setState(2195);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,273,_ctx) ) {
				case 1:
					{
					setState(2194);
					virtspecifierseq(0);
					}
					break;
				}
				setState(2198);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,274,_ctx) ) {
				case 1:
					{
					setState(2197);
					purespecifier();
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2200);
				declarator();
				setState(2202);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,275,_ctx) ) {
				case 1:
					{
					setState(2201);
					braceorequalinitializer();
					}
					break;
				}
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2205);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Identifier) {
					{
					setState(2204);
					match(Identifier);
					}
				}

				setState(2208);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2207);
					attributespecifierseq(0);
					}
				}

				setState(2210);
				match(Colon);
				setState(2211);
				constantexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class VirtspecifierseqContext extends ParserRuleContext {
		public VirtspecifierContext virtspecifier() {
			return getRuleContext(VirtspecifierContext.class,0);
		}
		public VirtspecifierseqContext virtspecifierseq() {
			return getRuleContext(VirtspecifierseqContext.class,0);
		}
		public VirtspecifierseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_virtspecifierseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterVirtspecifierseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitVirtspecifierseq(this);
		}
	}

	public final VirtspecifierseqContext virtspecifierseq() throws RecognitionException {
		return virtspecifierseq(0);
	}

	private VirtspecifierseqContext virtspecifierseq(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		VirtspecifierseqContext _localctx = new VirtspecifierseqContext(_ctx, _parentState);
		VirtspecifierseqContext _prevctx = _localctx;
		int _startState = 336;
		enterRecursionRule(_localctx, 336, RULE_virtspecifierseq, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2215);
			virtspecifier();
			}
			_ctx.stop = _input.LT(-1);
			setState(2221);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,279,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new VirtspecifierseqContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_virtspecifierseq);
					setState(2217);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2218);
					virtspecifier();
					}
					} 
				}
				setState(2223);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,279,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class VirtspecifierContext extends ParserRuleContext {
		public TerminalNode Override() { return getToken(CPP14Parser.Override, 0); }
		public TerminalNode Final() { return getToken(CPP14Parser.Final, 0); }
		public VirtspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_virtspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterVirtspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitVirtspecifier(this);
		}
	}

	public final VirtspecifierContext virtspecifier() throws RecognitionException {
		VirtspecifierContext _localctx = new VirtspecifierContext(_ctx, getState());
		enterRule(_localctx, 338, RULE_virtspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2224);
			_la = _input.LA(1);
			if ( !(_la==Final || _la==Override) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PurespecifierContext extends ParserRuleContext {
		public Token val;
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public TerminalNode Octalliteral() { return getToken(CPP14Parser.Octalliteral, 0); }
		public PurespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_purespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPurespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPurespecifier(this);
		}
	}

	public final PurespecifierContext purespecifier() throws RecognitionException {
		PurespecifierContext _localctx = new PurespecifierContext(_ctx, getState());
		enterRule(_localctx, 340, RULE_purespecifier);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2226);
			match(Assign);
			setState(2227);
			((PurespecifierContext)_localctx).val = match(Octalliteral);
			if((((PurespecifierContext)_localctx).val!=null?((PurespecifierContext)_localctx).val.getText():null).compareTo("0")!=0) throw new InputMismatchException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BaseclauseContext extends ParserRuleContext {
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public BasespecifierlistContext basespecifierlist() {
			return getRuleContext(BasespecifierlistContext.class,0);
		}
		public BaseclauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_baseclause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBaseclause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBaseclause(this);
		}
	}

	public final BaseclauseContext baseclause() throws RecognitionException {
		BaseclauseContext _localctx = new BaseclauseContext(_ctx, getState());
		enterRule(_localctx, 342, RULE_baseclause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2230);
			match(Colon);
			setState(2231);
			basespecifierlist(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BasespecifierlistContext extends ParserRuleContext {
		public BasespecifierContext basespecifier() {
			return getRuleContext(BasespecifierContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public BasespecifierlistContext basespecifierlist() {
			return getRuleContext(BasespecifierlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public BasespecifierlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_basespecifierlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBasespecifierlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBasespecifierlist(this);
		}
	}

	public final BasespecifierlistContext basespecifierlist() throws RecognitionException {
		return basespecifierlist(0);
	}

	private BasespecifierlistContext basespecifierlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		BasespecifierlistContext _localctx = new BasespecifierlistContext(_ctx, _parentState);
		BasespecifierlistContext _prevctx = _localctx;
		int _startState = 344;
		enterRecursionRule(_localctx, 344, RULE_basespecifierlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2234);
			basespecifier();
			setState(2236);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,280,_ctx) ) {
			case 1:
				{
				setState(2235);
				match(Ellipsis);
				}
				break;
			}
			}
			_ctx.stop = _input.LT(-1);
			setState(2246);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,282,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new BasespecifierlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_basespecifierlist);
					setState(2238);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2239);
					match(Comma);
					setState(2240);
					basespecifier();
					setState(2242);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,281,_ctx) ) {
					case 1:
						{
						setState(2241);
						match(Ellipsis);
						}
						break;
					}
					}
					} 
				}
				setState(2248);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,282,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BasespecifierContext extends ParserRuleContext {
		public BasetypespecifierContext basetypespecifier() {
			return getRuleContext(BasetypespecifierContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public TerminalNode Virtual() { return getToken(CPP14Parser.Virtual, 0); }
		public AccessspecifierContext accessspecifier() {
			return getRuleContext(AccessspecifierContext.class,0);
		}
		public BasespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_basespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBasespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBasespecifier(this);
		}
	}

	public final BasespecifierContext basespecifier() throws RecognitionException {
		BasespecifierContext _localctx = new BasespecifierContext(_ctx, getState());
		enterRule(_localctx, 346, RULE_basespecifier);
		int _la;
		try {
			setState(2270);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,288,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2250);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2249);
					attributespecifierseq(0);
					}
				}

				setState(2252);
				basetypespecifier();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2254);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2253);
					attributespecifierseq(0);
					}
				}

				setState(2256);
				match(Virtual);
				setState(2258);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & 31525197391593472L) != 0) {
					{
					setState(2257);
					accessspecifier();
					}
				}

				setState(2260);
				basetypespecifier();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2262);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2261);
					attributespecifierseq(0);
					}
				}

				setState(2264);
				accessspecifier();
				setState(2266);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Virtual) {
					{
					setState(2265);
					match(Virtual);
					}
				}

				setState(2268);
				basetypespecifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassordecltypeContext extends ParserRuleContext {
		public ClassnameContext classname() {
			return getRuleContext(ClassnameContext.class,0);
		}
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public DecltypespecifierContext decltypespecifier() {
			return getRuleContext(DecltypespecifierContext.class,0);
		}
		public ClassordecltypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classordecltype; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassordecltype(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassordecltype(this);
		}
	}

	public final ClassordecltypeContext classordecltype() throws RecognitionException {
		ClassordecltypeContext _localctx = new ClassordecltypeContext(_ctx, getState());
		enterRule(_localctx, 348, RULE_classordecltype);
		try {
			setState(2277);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,290,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2273);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) {
				case 1:
					{
					setState(2272);
					nestednamespecifier(0);
					}
					break;
				}
				setState(2275);
				classname();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2276);
				decltypespecifier();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BasetypespecifierContext extends ParserRuleContext {
		public ClassordecltypeContext classordecltype() {
			return getRuleContext(ClassordecltypeContext.class,0);
		}
		public BasetypespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_basetypespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBasetypespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBasetypespecifier(this);
		}
	}

	public final BasetypespecifierContext basetypespecifier() throws RecognitionException {
		BasetypespecifierContext _localctx = new BasetypespecifierContext(_ctx, getState());
		enterRule(_localctx, 350, RULE_basetypespecifier);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2279);
			classordecltype();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AccessspecifierContext extends ParserRuleContext {
		public TerminalNode Private() { return getToken(CPP14Parser.Private, 0); }
		public TerminalNode Protected() { return getToken(CPP14Parser.Protected, 0); }
		public TerminalNode Public() { return getToken(CPP14Parser.Public, 0); }
		public AccessspecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_accessspecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAccessspecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAccessspecifier(this);
		}
	}

	public final AccessspecifierContext accessspecifier() throws RecognitionException {
		AccessspecifierContext _localctx = new AccessspecifierContext(_ctx, getState());
		enterRule(_localctx, 352, RULE_accessspecifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2281);
			_la = _input.LA(1);
			if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 31525197391593472L) != 0) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConversionfunctionidContext extends ParserRuleContext {
		public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); }
		public ConversiontypeidContext conversiontypeid() {
			return getRuleContext(ConversiontypeidContext.class,0);
		}
		public ConversionfunctionidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conversionfunctionid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConversionfunctionid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConversionfunctionid(this);
		}
	}

	public final ConversionfunctionidContext conversionfunctionid() throws RecognitionException {
		ConversionfunctionidContext _localctx = new ConversionfunctionidContext(_ctx, getState());
		enterRule(_localctx, 354, RULE_conversionfunctionid);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2283);
			match(Operator);
			setState(2284);
			conversiontypeid();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConversiontypeidContext extends ParserRuleContext {
		public TypespecifierseqContext typespecifierseq() {
			return getRuleContext(TypespecifierseqContext.class,0);
		}
		public ConversiondeclaratorContext conversiondeclarator() {
			return getRuleContext(ConversiondeclaratorContext.class,0);
		}
		public ConversiontypeidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conversiontypeid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConversiontypeid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConversiontypeid(this);
		}
	}

	public final ConversiontypeidContext conversiontypeid() throws RecognitionException {
		ConversiontypeidContext _localctx = new ConversiontypeidContext(_ctx, getState());
		enterRule(_localctx, 356, RULE_conversiontypeid);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2286);
			typespecifierseq();
			setState(2288);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,291,_ctx) ) {
			case 1:
				{
				setState(2287);
				conversiondeclarator();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConversiondeclaratorContext extends ParserRuleContext {
		public PtroperatorContext ptroperator() {
			return getRuleContext(PtroperatorContext.class,0);
		}
		public ConversiondeclaratorContext conversiondeclarator() {
			return getRuleContext(ConversiondeclaratorContext.class,0);
		}
		public ConversiondeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conversiondeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConversiondeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConversiondeclarator(this);
		}
	}

	public final ConversiondeclaratorContext conversiondeclarator() throws RecognitionException {
		ConversiondeclaratorContext _localctx = new ConversiondeclaratorContext(_ctx, getState());
		enterRule(_localctx, 358, RULE_conversiondeclarator);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2290);
			ptroperator();
			setState(2292);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,292,_ctx) ) {
			case 1:
				{
				setState(2291);
				conversiondeclarator();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CtorinitializerContext extends ParserRuleContext {
		public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); }
		public MeminitializerlistContext meminitializerlist() {
			return getRuleContext(MeminitializerlistContext.class,0);
		}
		public CtorinitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ctorinitializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCtorinitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCtorinitializer(this);
		}
	}

	public final CtorinitializerContext ctorinitializer() throws RecognitionException {
		CtorinitializerContext _localctx = new CtorinitializerContext(_ctx, getState());
		enterRule(_localctx, 360, RULE_ctorinitializer);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2294);
			match(Colon);
			setState(2295);
			meminitializerlist();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MeminitializerlistContext extends ParserRuleContext {
		public MeminitializerContext meminitializer() {
			return getRuleContext(MeminitializerContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public MeminitializerlistContext meminitializerlist() {
			return getRuleContext(MeminitializerlistContext.class,0);
		}
		public MeminitializerlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_meminitializerlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMeminitializerlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMeminitializerlist(this);
		}
	}

	public final MeminitializerlistContext meminitializerlist() throws RecognitionException {
		MeminitializerlistContext _localctx = new MeminitializerlistContext(_ctx, getState());
		enterRule(_localctx, 362, RULE_meminitializerlist);
		int _la;
		try {
			setState(2308);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2297);
				meminitializer();
				setState(2299);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Ellipsis) {
					{
					setState(2298);
					match(Ellipsis);
					}
				}

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2301);
				meminitializer();
				setState(2303);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Ellipsis) {
					{
					setState(2302);
					match(Ellipsis);
					}
				}

				setState(2305);
				match(Comma);
				setState(2306);
				meminitializerlist();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MeminitializerContext extends ParserRuleContext {
		public MeminitializeridContext meminitializerid() {
			return getRuleContext(MeminitializeridContext.class,0);
		}
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public ExpressionlistContext expressionlist() {
			return getRuleContext(ExpressionlistContext.class,0);
		}
		public BracedinitlistContext bracedinitlist() {
			return getRuleContext(BracedinitlistContext.class,0);
		}
		public MeminitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_meminitializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMeminitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMeminitializer(this);
		}
	}

	public final MeminitializerContext meminitializer() throws RecognitionException {
		MeminitializerContext _localctx = new MeminitializerContext(_ctx, getState());
		enterRule(_localctx, 364, RULE_meminitializer);
		int _la;
		try {
			setState(2320);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,297,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2310);
				meminitializerid();
				setState(2311);
				match(LeftParen);
				setState(2313);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564186457925114L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132927793001L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(2312);
					expressionlist();
					}
				}

				setState(2315);
				match(RightParen);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2317);
				meminitializerid();
				setState(2318);
				bracedinitlist();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MeminitializeridContext extends ParserRuleContext {
		public ClassordecltypeContext classordecltype() {
			return getRuleContext(ClassordecltypeContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public MeminitializeridContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_meminitializerid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMeminitializerid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMeminitializerid(this);
		}
	}

	public final MeminitializeridContext meminitializerid() throws RecognitionException {
		MeminitializeridContext _localctx = new MeminitializeridContext(_ctx, getState());
		enterRule(_localctx, 366, RULE_meminitializerid);
		try {
			setState(2324);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2322);
				classordecltype();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2323);
				match(Identifier);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OperatorfunctionidContext extends ParserRuleContext {
		public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); }
		public TheoperatorContext theoperator() {
			return getRuleContext(TheoperatorContext.class,0);
		}
		public OperatorfunctionidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_operatorfunctionid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOperatorfunctionid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOperatorfunctionid(this);
		}
	}

	public final OperatorfunctionidContext operatorfunctionid() throws RecognitionException {
		OperatorfunctionidContext _localctx = new OperatorfunctionidContext(_ctx, getState());
		enterRule(_localctx, 368, RULE_operatorfunctionid);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2326);
			match(Operator);
			setState(2327);
			theoperator();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LiteraloperatoridContext extends ParserRuleContext {
		public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); }
		public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode Userdefinedstringliteral() { return getToken(CPP14Parser.Userdefinedstringliteral, 0); }
		public LiteraloperatoridContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literaloperatorid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLiteraloperatorid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLiteraloperatorid(this);
		}
	}

	public final LiteraloperatoridContext literaloperatorid() throws RecognitionException {
		LiteraloperatoridContext _localctx = new LiteraloperatoridContext(_ctx, getState());
		enterRule(_localctx, 370, RULE_literaloperatorid);
		try {
			setState(2334);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,299,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2329);
				match(Operator);
				setState(2330);
				match(Stringliteral);
				setState(2331);
				match(Identifier);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2332);
				match(Operator);
				setState(2333);
				match(Userdefinedstringliteral);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TemplatedeclarationContext extends ParserRuleContext {
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public TemplateparameterlistContext templateparameterlist() {
			return getRuleContext(TemplateparameterlistContext.class,0);
		}
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public DeclarationContext declaration() {
			return getRuleContext(DeclarationContext.class,0);
		}
		public TemplatedeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_templatedeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplatedeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplatedeclaration(this);
		}
	}

	public final TemplatedeclarationContext templatedeclaration() throws RecognitionException {
		TemplatedeclarationContext _localctx = new TemplatedeclarationContext(_ctx, getState());
		enterRule(_localctx, 372, RULE_templatedeclaration);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2336);
			match(Template);
			setState(2337);
			match(Less);
			setState(2338);
			templateparameterlist(0);
			setState(2339);
			match(Greater);
			setState(2340);
			declaration();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TemplateparameterlistContext extends ParserRuleContext {
		public TemplateparameterContext templateparameter() {
			return getRuleContext(TemplateparameterContext.class,0);
		}
		public TemplateparameterlistContext templateparameterlist() {
			return getRuleContext(TemplateparameterlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public TemplateparameterlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_templateparameterlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateparameterlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateparameterlist(this);
		}
	}

	public final TemplateparameterlistContext templateparameterlist() throws RecognitionException {
		return templateparameterlist(0);
	}

	private TemplateparameterlistContext templateparameterlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		TemplateparameterlistContext _localctx = new TemplateparameterlistContext(_ctx, _parentState);
		TemplateparameterlistContext _prevctx = _localctx;
		int _startState = 374;
		enterRecursionRule(_localctx, 374, RULE_templateparameterlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2343);
			templateparameter();
			}
			_ctx.stop = _input.LT(-1);
			setState(2350);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,300,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new TemplateparameterlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_templateparameterlist);
					setState(2345);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2346);
					match(Comma);
					setState(2347);
					templateparameter();
					}
					} 
				}
				setState(2352);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,300,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TemplateparameterContext extends ParserRuleContext {
		public TypeparameterContext typeparameter() {
			return getRuleContext(TypeparameterContext.class,0);
		}
		public ParameterdeclarationContext parameterdeclaration() {
			return getRuleContext(ParameterdeclarationContext.class,0);
		}
		public TemplateparameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_templateparameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateparameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateparameter(this);
		}
	}

	public final TemplateparameterContext templateparameter() throws RecognitionException {
		TemplateparameterContext _localctx = new TemplateparameterContext(_ctx, getState());
		enterRule(_localctx, 376, RULE_templateparameter);
		try {
			setState(2355);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,301,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2353);
				typeparameter();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2354);
				parameterdeclaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeparameterContext extends ParserRuleContext {
		public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); }
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode Typename_() { return getToken(CPP14Parser.Typename_, 0); }
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public TemplateparameterlistContext templateparameterlist() {
			return getRuleContext(TemplateparameterlistContext.class,0);
		}
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public IdexpressionContext idexpression() {
			return getRuleContext(IdexpressionContext.class,0);
		}
		public TypeparameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeparameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypeparameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypeparameter(this);
		}
	}

	public final TypeparameterContext typeparameter() throws RecognitionException {
		TypeparameterContext _localctx = new TypeparameterContext(_ctx, getState());
		enterRule(_localctx, 378, RULE_typeparameter);
		int _la;
		try {
			setState(2405);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,311,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2357);
				match(Class);
				setState(2359);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,302,_ctx) ) {
				case 1:
					{
					setState(2358);
					match(Ellipsis);
					}
					break;
				}
				setState(2362);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,303,_ctx) ) {
				case 1:
					{
					setState(2361);
					match(Identifier);
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2364);
				match(Class);
				setState(2366);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Identifier) {
					{
					setState(2365);
					match(Identifier);
					}
				}

				setState(2368);
				match(Assign);
				setState(2369);
				thetypeid();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2370);
				match(Typename_);
				setState(2372);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,305,_ctx) ) {
				case 1:
					{
					setState(2371);
					match(Ellipsis);
					}
					break;
				}
				setState(2375);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,306,_ctx) ) {
				case 1:
					{
					setState(2374);
					match(Identifier);
					}
					break;
				}
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(2377);
				match(Typename_);
				setState(2379);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Identifier) {
					{
					setState(2378);
					match(Identifier);
					}
				}

				setState(2381);
				match(Assign);
				setState(2382);
				thetypeid();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(2383);
				match(Template);
				setState(2384);
				match(Less);
				setState(2385);
				templateparameterlist(0);
				setState(2386);
				match(Greater);
				setState(2387);
				match(Class);
				setState(2389);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,308,_ctx) ) {
				case 1:
					{
					setState(2388);
					match(Ellipsis);
					}
					break;
				}
				setState(2392);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,309,_ctx) ) {
				case 1:
					{
					setState(2391);
					match(Identifier);
					}
					break;
				}
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(2394);
				match(Template);
				setState(2395);
				match(Less);
				setState(2396);
				templateparameterlist(0);
				setState(2397);
				match(Greater);
				setState(2398);
				match(Class);
				setState(2400);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Identifier) {
					{
					setState(2399);
					match(Identifier);
					}
				}

				setState(2402);
				match(Assign);
				setState(2403);
				idexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class SimpletemplateidContext extends ParserRuleContext {
		public TemplatenameContext templatename() {
			return getRuleContext(TemplatenameContext.class,0);
		}
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public TemplateargumentlistContext templateargumentlist() {
			return getRuleContext(TemplateargumentlistContext.class,0);
		}
		public SimpletemplateidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_simpletemplateid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimpletemplateid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimpletemplateid(this);
		}
	}

	public final SimpletemplateidContext simpletemplateid() throws RecognitionException {
		SimpletemplateidContext _localctx = new SimpletemplateidContext(_ctx, getState());
		enterRule(_localctx, 380, RULE_simpletemplateid);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2407);
			templatename();
			setState(2408);
			match(Less);
			setState(2410);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564184308868602L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911081293L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
				{
				setState(2409);
				templateargumentlist(0);
				}
			}

			setState(2412);
			match(Greater);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TemplateidContext extends ParserRuleContext {
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public OperatorfunctionidContext operatorfunctionid() {
			return getRuleContext(OperatorfunctionidContext.class,0);
		}
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public TemplateargumentlistContext templateargumentlist() {
			return getRuleContext(TemplateargumentlistContext.class,0);
		}
		public LiteraloperatoridContext literaloperatorid() {
			return getRuleContext(LiteraloperatoridContext.class,0);
		}
		public TemplateidContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_templateid; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateid(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateid(this);
		}
	}

	public final TemplateidContext templateid() throws RecognitionException {
		TemplateidContext _localctx = new TemplateidContext(_ctx, getState());
		enterRule(_localctx, 382, RULE_templateid);
		int _la;
		try {
			setState(2429);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,315,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2414);
				simpletemplateid();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2415);
				operatorfunctionid();
				setState(2416);
				match(Less);
				setState(2418);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564184308868602L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911081293L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(2417);
					templateargumentlist(0);
					}
				}

				setState(2420);
				match(Greater);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2422);
				literaloperatorid();
				setState(2423);
				match(Less);
				setState(2425);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (((_la) & ~0x3f) == 0 && ((1L << _la) & -7131564184308868602L) != 0 || (((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1179943132911081293L) != 0 || (((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & 16259L) != 0) {
					{
					setState(2424);
					templateargumentlist(0);
					}
				}

				setState(2427);
				match(Greater);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TemplatenameContext extends ParserRuleContext {
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public TemplatenameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_templatename; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplatename(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplatename(this);
		}
	}

	public final TemplatenameContext templatename() throws RecognitionException {
		TemplatenameContext _localctx = new TemplatenameContext(_ctx, getState());
		enterRule(_localctx, 384, RULE_templatename);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2431);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TemplateargumentlistContext extends ParserRuleContext {
		public TemplateargumentContext templateargument() {
			return getRuleContext(TemplateargumentContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public TemplateargumentlistContext templateargumentlist() {
			return getRuleContext(TemplateargumentlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public TemplateargumentlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_templateargumentlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateargumentlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateargumentlist(this);
		}
	}

	public final TemplateargumentlistContext templateargumentlist() throws RecognitionException {
		return templateargumentlist(0);
	}

	private TemplateargumentlistContext templateargumentlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		TemplateargumentlistContext _localctx = new TemplateargumentlistContext(_ctx, _parentState);
		TemplateargumentlistContext _prevctx = _localctx;
		int _startState = 386;
		enterRecursionRule(_localctx, 386, RULE_templateargumentlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2434);
			templateargument();
			setState(2436);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,316,_ctx) ) {
			case 1:
				{
				setState(2435);
				match(Ellipsis);
				}
				break;
			}
			}
			_ctx.stop = _input.LT(-1);
			setState(2446);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,318,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new TemplateargumentlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_templateargumentlist);
					setState(2438);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2439);
					match(Comma);
					setState(2440);
					templateargument();
					setState(2442);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,317,_ctx) ) {
					case 1:
						{
						setState(2441);
						match(Ellipsis);
						}
						break;
					}
					}
					} 
				}
				setState(2448);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,318,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TemplateargumentContext extends ParserRuleContext {
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public IdexpressionContext idexpression() {
			return getRuleContext(IdexpressionContext.class,0);
		}
		public TemplateargumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_templateargument; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateargument(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateargument(this);
		}
	}

	public final TemplateargumentContext templateargument() throws RecognitionException {
		TemplateargumentContext _localctx = new TemplateargumentContext(_ctx, getState());
		enterRule(_localctx, 388, RULE_templateargument);
		try {
			setState(2452);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,319,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2449);
				thetypeid();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2450);
				constantexpression();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2451);
				idexpression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypenamespecifierContext extends ParserRuleContext {
		public TerminalNode Typename_() { return getToken(CPP14Parser.Typename_, 0); }
		public NestednamespecifierContext nestednamespecifier() {
			return getRuleContext(NestednamespecifierContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
		public SimpletemplateidContext simpletemplateid() {
			return getRuleContext(SimpletemplateidContext.class,0);
		}
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public TypenamespecifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typenamespecifier; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypenamespecifier(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypenamespecifier(this);
		}
	}

	public final TypenamespecifierContext typenamespecifier() throws RecognitionException {
		TypenamespecifierContext _localctx = new TypenamespecifierContext(_ctx, getState());
		enterRule(_localctx, 390, RULE_typenamespecifier);
		int _la;
		try {
			setState(2465);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,321,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2454);
				match(Typename_);
				setState(2455);
				nestednamespecifier(0);
				setState(2456);
				match(Identifier);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2458);
				match(Typename_);
				setState(2459);
				nestednamespecifier(0);
				setState(2461);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Template) {
					{
					setState(2460);
					match(Template);
					}
				}

				setState(2463);
				simpletemplateid();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExplicitinstantiationContext extends ParserRuleContext {
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public DeclarationContext declaration() {
			return getRuleContext(DeclarationContext.class,0);
		}
		public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); }
		public ExplicitinstantiationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_explicitinstantiation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExplicitinstantiation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExplicitinstantiation(this);
		}
	}

	public final ExplicitinstantiationContext explicitinstantiation() throws RecognitionException {
		ExplicitinstantiationContext _localctx = new ExplicitinstantiationContext(_ctx, getState());
		enterRule(_localctx, 392, RULE_explicitinstantiation);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2468);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Extern) {
				{
				setState(2467);
				match(Extern);
				}
			}

			setState(2470);
			match(Template);
			setState(2471);
			declaration();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExplicitspecializationContext extends ParserRuleContext {
		public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public DeclarationContext declaration() {
			return getRuleContext(DeclarationContext.class,0);
		}
		public ExplicitspecializationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_explicitspecialization; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExplicitspecialization(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExplicitspecialization(this);
		}
	}

	public final ExplicitspecializationContext explicitspecialization() throws RecognitionException {
		ExplicitspecializationContext _localctx = new ExplicitspecializationContext(_ctx, getState());
		enterRule(_localctx, 394, RULE_explicitspecialization);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2473);
			match(Template);
			setState(2474);
			match(Less);
			setState(2475);
			match(Greater);
			setState(2476);
			declaration();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TryblockContext extends ParserRuleContext {
		public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); }
		public CompoundstatementContext compoundstatement() {
			return getRuleContext(CompoundstatementContext.class,0);
		}
		public HandlerseqContext handlerseq() {
			return getRuleContext(HandlerseqContext.class,0);
		}
		public TryblockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tryblock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTryblock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTryblock(this);
		}
	}

	public final TryblockContext tryblock() throws RecognitionException {
		TryblockContext _localctx = new TryblockContext(_ctx, getState());
		enterRule(_localctx, 396, RULE_tryblock);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2478);
			match(Try);
			setState(2479);
			compoundstatement();
			setState(2480);
			handlerseq();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FunctiontryblockContext extends ParserRuleContext {
		public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); }
		public CompoundstatementContext compoundstatement() {
			return getRuleContext(CompoundstatementContext.class,0);
		}
		public HandlerseqContext handlerseq() {
			return getRuleContext(HandlerseqContext.class,0);
		}
		public CtorinitializerContext ctorinitializer() {
			return getRuleContext(CtorinitializerContext.class,0);
		}
		public FunctiontryblockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functiontryblock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctiontryblock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctiontryblock(this);
		}
	}

	public final FunctiontryblockContext functiontryblock() throws RecognitionException {
		FunctiontryblockContext _localctx = new FunctiontryblockContext(_ctx, getState());
		enterRule(_localctx, 398, RULE_functiontryblock);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2482);
			match(Try);
			setState(2484);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Colon) {
				{
				setState(2483);
				ctorinitializer();
				}
			}

			setState(2486);
			compoundstatement();
			setState(2487);
			handlerseq();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class HandlerseqContext extends ParserRuleContext {
		public HandlerContext handler() {
			return getRuleContext(HandlerContext.class,0);
		}
		public HandlerseqContext handlerseq() {
			return getRuleContext(HandlerseqContext.class,0);
		}
		public HandlerseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_handlerseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterHandlerseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitHandlerseq(this);
		}
	}

	public final HandlerseqContext handlerseq() throws RecognitionException {
		HandlerseqContext _localctx = new HandlerseqContext(_ctx, getState());
		enterRule(_localctx, 400, RULE_handlerseq);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2489);
			handler();
			setState(2491);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,324,_ctx) ) {
			case 1:
				{
				setState(2490);
				handlerseq();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class HandlerContext extends ParserRuleContext {
		public TerminalNode Catch() { return getToken(CPP14Parser.Catch, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ExceptiondeclarationContext exceptiondeclaration() {
			return getRuleContext(ExceptiondeclarationContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public CompoundstatementContext compoundstatement() {
			return getRuleContext(CompoundstatementContext.class,0);
		}
		public HandlerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_handler; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterHandler(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitHandler(this);
		}
	}

	public final HandlerContext handler() throws RecognitionException {
		HandlerContext _localctx = new HandlerContext(_ctx, getState());
		enterRule(_localctx, 402, RULE_handler);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2493);
			match(Catch);
			setState(2494);
			match(LeftParen);
			setState(2495);
			exceptiondeclaration();
			setState(2496);
			match(RightParen);
			setState(2497);
			compoundstatement();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExceptiondeclarationContext extends ParserRuleContext {
		public TypespecifierseqContext typespecifierseq() {
			return getRuleContext(TypespecifierseqContext.class,0);
		}
		public DeclaratorContext declarator() {
			return getRuleContext(DeclaratorContext.class,0);
		}
		public AttributespecifierseqContext attributespecifierseq() {
			return getRuleContext(AttributespecifierseqContext.class,0);
		}
		public AbstractdeclaratorContext abstractdeclarator() {
			return getRuleContext(AbstractdeclaratorContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public ExceptiondeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exceptiondeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExceptiondeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExceptiondeclaration(this);
		}
	}

	public final ExceptiondeclarationContext exceptiondeclaration() throws RecognitionException {
		ExceptiondeclarationContext _localctx = new ExceptiondeclarationContext(_ctx, getState());
		enterRule(_localctx, 404, RULE_exceptiondeclaration);
		int _la;
		try {
			setState(2513);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,328,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2500);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2499);
					attributespecifierseq(0);
					}
				}

				setState(2502);
				typespecifierseq();
				setState(2503);
				declarator();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2506);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Alignas || _la==LeftBracket) {
					{
					setState(2505);
					attributespecifierseq(0);
					}
				}

				setState(2508);
				typespecifierseq();
				setState(2510);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__3 || _la==Decltype || (((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 53876069765381L) != 0) {
					{
					setState(2509);
					abstractdeclarator();
					}
				}

				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2512);
				match(Ellipsis);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ThrowexpressionContext extends ParserRuleContext {
		public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); }
		public AssignmentexpressionContext assignmentexpression() {
			return getRuleContext(AssignmentexpressionContext.class,0);
		}
		public ThrowexpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_throwexpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterThrowexpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitThrowexpression(this);
		}
	}

	public final ThrowexpressionContext throwexpression() throws RecognitionException {
		ThrowexpressionContext _localctx = new ThrowexpressionContext(_ctx, getState());
		enterRule(_localctx, 406, RULE_throwexpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2515);
			match(Throw);
			setState(2517);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,329,_ctx) ) {
			case 1:
				{
				setState(2516);
				assignmentexpression();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExceptionspecificationContext extends ParserRuleContext {
		public DynamicexceptionspecificationContext dynamicexceptionspecification() {
			return getRuleContext(DynamicexceptionspecificationContext.class,0);
		}
		public NoexceptspecificationContext noexceptspecification() {
			return getRuleContext(NoexceptspecificationContext.class,0);
		}
		public ExceptionspecificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exceptionspecification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExceptionspecification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExceptionspecification(this);
		}
	}

	public final ExceptionspecificationContext exceptionspecification() throws RecognitionException {
		ExceptionspecificationContext _localctx = new ExceptionspecificationContext(_ctx, getState());
		enterRule(_localctx, 408, RULE_exceptionspecification);
		try {
			setState(2521);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Throw:
				enterOuterAlt(_localctx, 1);
				{
				setState(2519);
				dynamicexceptionspecification();
				}
				break;
			case Noexcept:
				enterOuterAlt(_localctx, 2);
				{
				setState(2520);
				noexceptspecification();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DynamicexceptionspecificationContext extends ParserRuleContext {
		public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TypeidlistContext typeidlist() {
			return getRuleContext(TypeidlistContext.class,0);
		}
		public DynamicexceptionspecificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dynamicexceptionspecification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDynamicexceptionspecification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDynamicexceptionspecification(this);
		}
	}

	public final DynamicexceptionspecificationContext dynamicexceptionspecification() throws RecognitionException {
		DynamicexceptionspecificationContext _localctx = new DynamicexceptionspecificationContext(_ctx, getState());
		enterRule(_localctx, 410, RULE_dynamicexceptionspecification);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2523);
			match(Throw);
			setState(2524);
			match(LeftParen);
			setState(2526);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la - 11)) & ~0x3f) == 0 && ((1L << (_la - 11)) & -6872070805949111325L) != 0 || (((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & 9288674231451705L) != 0) {
				{
				setState(2525);
				typeidlist(0);
				}
			}

			setState(2528);
			match(RightParen);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeidlistContext extends ParserRuleContext {
		public ThetypeidContext thetypeid() {
			return getRuleContext(ThetypeidContext.class,0);
		}
		public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); }
		public TypeidlistContext typeidlist() {
			return getRuleContext(TypeidlistContext.class,0);
		}
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public TypeidlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeidlist; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypeidlist(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypeidlist(this);
		}
	}

	public final TypeidlistContext typeidlist() throws RecognitionException {
		return typeidlist(0);
	}

	private TypeidlistContext typeidlist(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		TypeidlistContext _localctx = new TypeidlistContext(_ctx, _parentState);
		TypeidlistContext _prevctx = _localctx;
		int _startState = 412;
		enterRecursionRule(_localctx, 412, RULE_typeidlist, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2531);
			thetypeid();
			setState(2533);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,332,_ctx) ) {
			case 1:
				{
				setState(2532);
				match(Ellipsis);
				}
				break;
			}
			}
			_ctx.stop = _input.LT(-1);
			setState(2543);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,334,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new TypeidlistContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_typeidlist);
					setState(2535);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2536);
					match(Comma);
					setState(2537);
					thetypeid();
					setState(2539);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,333,_ctx) ) {
					case 1:
						{
						setState(2538);
						match(Ellipsis);
						}
						break;
					}
					}
					} 
				}
				setState(2545);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,334,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NoexceptspecificationContext extends ParserRuleContext {
		public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public ConstantexpressionContext constantexpression() {
			return getRuleContext(ConstantexpressionContext.class,0);
		}
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public NoexceptspecificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_noexceptspecification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoexceptspecification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoexceptspecification(this);
		}
	}

	public final NoexceptspecificationContext noexceptspecification() throws RecognitionException {
		NoexceptspecificationContext _localctx = new NoexceptspecificationContext(_ctx, getState());
		enterRule(_localctx, 414, RULE_noexceptspecification);
		try {
			setState(2552);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,335,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2546);
				match(Noexcept);
				setState(2547);
				match(LeftParen);
				setState(2548);
				constantexpression();
				setState(2549);
				match(RightParen);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2551);
				match(Noexcept);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LeftShiftContext extends ParserRuleContext {
		public List<TerminalNode> Less() { return getTokens(CPP14Parser.Less); }
		public TerminalNode Less(int i) {
			return getToken(CPP14Parser.Less, i);
		}
		public LeftShiftContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_leftShift; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLeftShift(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLeftShift(this);
		}
	}

	public final LeftShiftContext leftShift() throws RecognitionException {
		LeftShiftContext _localctx = new LeftShiftContext(_ctx, getState());
		enterRule(_localctx, 416, RULE_leftShift);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2554);
			match(Less);
			setState(2555);
			match(Less);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LeftShiftAssignContext extends ParserRuleContext {
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public TerminalNode LessEqual() { return getToken(CPP14Parser.LessEqual, 0); }
		public LeftShiftAssignContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_leftShiftAssign; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLeftShiftAssign(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLeftShiftAssign(this);
		}
	}

	public final LeftShiftAssignContext leftShiftAssign() throws RecognitionException {
		LeftShiftAssignContext _localctx = new LeftShiftAssignContext(_ctx, getState());
		enterRule(_localctx, 418, RULE_leftShiftAssign);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2557);
			match(Less);
			setState(2558);
			match(LessEqual);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RightShiftContext extends ParserRuleContext {
		public List<TerminalNode> Greater() { return getTokens(CPP14Parser.Greater); }
		public TerminalNode Greater(int i) {
			return getToken(CPP14Parser.Greater, i);
		}
		public RightShiftContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rightShift; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRightShift(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRightShift(this);
		}
	}

	public final RightShiftContext rightShift() throws RecognitionException {
		RightShiftContext _localctx = new RightShiftContext(_ctx, getState());
		enterRule(_localctx, 420, RULE_rightShift);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2560);
			match(Greater);
			setState(2561);
			match(Greater);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class RightShiftAssignContext extends ParserRuleContext {
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public TerminalNode GreaterEqual() { return getToken(CPP14Parser.GreaterEqual, 0); }
		public RightShiftAssignContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rightShiftAssign; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRightShiftAssign(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRightShiftAssign(this);
		}
	}

	public final RightShiftAssignContext rightShiftAssign() throws RecognitionException {
		RightShiftAssignContext _localctx = new RightShiftAssignContext(_ctx, getState());
		enterRule(_localctx, 422, RULE_rightShiftAssign);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2563);
			match(Greater);
			setState(2564);
			match(GreaterEqual);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TheoperatorContext extends ParserRuleContext {
		public TerminalNode New() { return getToken(CPP14Parser.New, 0); }
		public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); }
		public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); }
		public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); }
		public TerminalNode Plus() { return getToken(CPP14Parser.Plus, 0); }
		public TerminalNode Minus() { return getToken(CPP14Parser.Minus, 0); }
		public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); }
		public TerminalNode Div() { return getToken(CPP14Parser.Div, 0); }
		public TerminalNode Mod() { return getToken(CPP14Parser.Mod, 0); }
		public TerminalNode Caret() { return getToken(CPP14Parser.Caret, 0); }
		public TerminalNode And() { return getToken(CPP14Parser.And, 0); }
		public TerminalNode Or() { return getToken(CPP14Parser.Or, 0); }
		public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); }
		public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
		public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); }
		public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); }
		public TerminalNode PlusAssign() { return getToken(CPP14Parser.PlusAssign, 0); }
		public TerminalNode MinusAssign() { return getToken(CPP14Parser.MinusAssign, 0); }
		public TerminalNode StarAssign() { return getToken(CPP14Parser.StarAssign, 0); }
		public TerminalNode DivAssign() { return getToken(CPP14Parser.DivAssign, 0); }
		public TerminalNode ModAssign() { return getToken(CPP14Parser.ModAssign, 0); }
		public TerminalNode XorAssign() { return getToken(CPP14Parser.XorAssign, 0); }
		public TerminalNode AndAssign() { return getToken(CPP14Parser.AndAssign, 0); }
		public TerminalNode OrAssign() { return getToken(CPP14Parser.OrAssign, 0); }
		public LeftShiftContext leftShift() {
			return getRuleContext(LeftShiftContext.class,0);
		}
		public RightShiftContext rightShift() {
			return getRuleContext(RightShiftContext.class,0);
		}
		public RightShiftAssignContext rightShiftAssign() {
			return getRuleContext(RightShiftAssignContext.class,0);
		}
		public LeftShiftAssignContext leftShiftAssign() {
			return getRuleContext(LeftShiftAssignContext.class,0);
		}
		public TerminalNode Equal() { return getToken(CPP14Parser.Equal, 0); }
		public TerminalNode NotEqual() { return getToken(CPP14Parser.NotEqual, 0); }
		public TerminalNode LessEqual() { return getToken(CPP14Parser.LessEqual, 0); }
		public TerminalNode GreaterEqual() { return getToken(CPP14Parser.GreaterEqual, 0); }
		public TerminalNode PlusPlus() { return getToken(CPP14Parser.PlusPlus, 0); }
		public TerminalNode MinusMinus() { return getToken(CPP14Parser.MinusMinus, 0); }
		public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); }
		public TerminalNode ArrowStar() { return getToken(CPP14Parser.ArrowStar, 0); }
		public TerminalNode Arrow() { return getToken(CPP14Parser.Arrow, 0); }
		public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); }
		public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); }
		public TheoperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_theoperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTheoperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTheoperator(this);
		}
	}

	public final TheoperatorContext theoperator() throws RecognitionException {
		TheoperatorContext _localctx = new TheoperatorContext(_ctx, getState());
		enterRule(_localctx, 424, RULE_theoperator);
		try {
			setState(2617);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,336,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(2566);
				match(New);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(2567);
				match(Delete);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(2568);
				match(New);
				setState(2569);
				match(LeftBracket);
				setState(2570);
				match(RightBracket);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(2571);
				match(Delete);
				setState(2572);
				match(LeftBracket);
				setState(2573);
				match(RightBracket);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(2574);
				match(Plus);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(2575);
				match(Minus);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(2576);
				match(Star);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(2577);
				match(Div);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(2578);
				match(Mod);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(2579);
				match(Caret);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(2580);
				match(And);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(2581);
				match(Or);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(2582);
				match(Tilde);
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(2583);
				match(T__0);
				}
				break;
			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(2584);
				match(T__1);
				}
				break;
			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(2585);
				match(Assign);
				}
				break;
			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(2586);
				match(Less);
				}
				break;
			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(2587);
				match(Greater);
				}
				break;
			case 19:
				enterOuterAlt(_localctx, 19);
				{
				setState(2588);
				match(PlusAssign);
				}
				break;
			case 20:
				enterOuterAlt(_localctx, 20);
				{
				setState(2589);
				match(MinusAssign);
				}
				break;
			case 21:
				enterOuterAlt(_localctx, 21);
				{
				setState(2590);
				match(StarAssign);
				}
				break;
			case 22:
				enterOuterAlt(_localctx, 22);
				{
				setState(2591);
				match(DivAssign);
				}
				break;
			case 23:
				enterOuterAlt(_localctx, 23);
				{
				setState(2592);
				match(ModAssign);
				}
				break;
			case 24:
				enterOuterAlt(_localctx, 24);
				{
				setState(2593);
				match(XorAssign);
				}
				break;
			case 25:
				enterOuterAlt(_localctx, 25);
				{
				setState(2594);
				match(AndAssign);
				}
				break;
			case 26:
				enterOuterAlt(_localctx, 26);
				{
				setState(2595);
				match(OrAssign);
				}
				break;
			case 27:
				enterOuterAlt(_localctx, 27);
				{
				setState(2596);
				leftShift();
				}
				break;
			case 28:
				enterOuterAlt(_localctx, 28);
				{
				setState(2597);
				rightShift();
				}
				break;
			case 29:
				enterOuterAlt(_localctx, 29);
				{
				setState(2598);
				rightShiftAssign();
				}
				break;
			case 30:
				enterOuterAlt(_localctx, 30);
				{
				setState(2599);
				leftShiftAssign();
				}
				break;
			case 31:
				enterOuterAlt(_localctx, 31);
				{
				setState(2600);
				match(Equal);
				}
				break;
			case 32:
				enterOuterAlt(_localctx, 32);
				{
				setState(2601);
				match(NotEqual);
				}
				break;
			case 33:
				enterOuterAlt(_localctx, 33);
				{
				setState(2602);
				match(LessEqual);
				}
				break;
			case 34:
				enterOuterAlt(_localctx, 34);
				{
				setState(2603);
				match(GreaterEqual);
				}
				break;
			case 35:
				enterOuterAlt(_localctx, 35);
				{
				setState(2604);
				match(T__3);
				}
				break;
			case 36:
				enterOuterAlt(_localctx, 36);
				{
				setState(2605);
				match(T__2);
				}
				break;
			case 37:
				enterOuterAlt(_localctx, 37);
				{
				setState(2606);
				match(T__5);
				}
				break;
			case 38:
				enterOuterAlt(_localctx, 38);
				{
				setState(2607);
				match(T__4);
				}
				break;
			case 39:
				enterOuterAlt(_localctx, 39);
				{
				setState(2608);
				match(PlusPlus);
				}
				break;
			case 40:
				enterOuterAlt(_localctx, 40);
				{
				setState(2609);
				match(MinusMinus);
				}
				break;
			case 41:
				enterOuterAlt(_localctx, 41);
				{
				setState(2610);
				match(Comma);
				}
				break;
			case 42:
				enterOuterAlt(_localctx, 42);
				{
				setState(2611);
				match(ArrowStar);
				}
				break;
			case 43:
				enterOuterAlt(_localctx, 43);
				{
				setState(2612);
				match(Arrow);
				}
				break;
			case 44:
				enterOuterAlt(_localctx, 44);
				{
				setState(2613);
				match(LeftParen);
				setState(2614);
				match(RightParen);
				}
				break;
			case 45:
				enterOuterAlt(_localctx, 45);
				{
				setState(2615);
				match(LeftBracket);
				setState(2616);
				match(RightBracket);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class LiteralContext extends ParserRuleContext {
		public TerminalNode Integerliteral() { return getToken(CPP14Parser.Integerliteral, 0); }
		public TerminalNode Characterliteral() { return getToken(CPP14Parser.Characterliteral, 0); }
		public TerminalNode Floatingliteral() { return getToken(CPP14Parser.Floatingliteral, 0); }
		public StringliteralseqContext stringliteralseq() {
			return getRuleContext(StringliteralseqContext.class,0);
		}
		public BooleanliteralContext booleanliteral() {
			return getRuleContext(BooleanliteralContext.class,0);
		}
		public PointerliteralContext pointerliteral() {
			return getRuleContext(PointerliteralContext.class,0);
		}
		public UserdefinedliteralContext userdefinedliteral() {
			return getRuleContext(UserdefinedliteralContext.class,0);
		}
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLiteral(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 426, RULE_literal);
		try {
			setState(2626);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Integerliteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(2619);
				match(Integerliteral);
				}
				break;
			case Characterliteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(2620);
				match(Characterliteral);
				}
				break;
			case Floatingliteral:
				enterOuterAlt(_localctx, 3);
				{
				setState(2621);
				match(Floatingliteral);
				}
				break;
			case Stringliteral:
				enterOuterAlt(_localctx, 4);
				{
				setState(2622);
				stringliteralseq(0);
				}
				break;
			case False:
			case True:
				enterOuterAlt(_localctx, 5);
				{
				setState(2623);
				booleanliteral();
				}
				break;
			case Nullptr:
				enterOuterAlt(_localctx, 6);
				{
				setState(2624);
				pointerliteral();
				}
				break;
			case Userdefinedintegerliteral:
			case Userdefinedfloatingliteral:
			case Userdefinedstringliteral:
			case Userdefinedcharacterliteral:
				enterOuterAlt(_localctx, 7);
				{
				setState(2625);
				userdefinedliteral();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StringliteralseqContext extends ParserRuleContext {
		public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
		public StringliteralseqContext stringliteralseq() {
			return getRuleContext(StringliteralseqContext.class,0);
		}
		public StringliteralseqContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stringliteralseq; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStringliteralseq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStringliteralseq(this);
		}
	}

	public final StringliteralseqContext stringliteralseq() throws RecognitionException {
		return stringliteralseq(0);
	}

	private StringliteralseqContext stringliteralseq(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		StringliteralseqContext _localctx = new StringliteralseqContext(_ctx, _parentState);
		StringliteralseqContext _prevctx = _localctx;
		int _startState = 428;
		enterRecursionRule(_localctx, 428, RULE_stringliteralseq, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(2629);
			match(Stringliteral);
			}
			_ctx.stop = _input.LT(-1);
			setState(2635);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,338,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new StringliteralseqContext(_parentctx, _parentState);
					pushNewRecursionContext(_localctx, _startState, RULE_stringliteralseq);
					setState(2631);
					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
					setState(2632);
					match(Stringliteral);
					}
					} 
				}
				setState(2637);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,338,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BooleanliteralContext extends ParserRuleContext {
		public TerminalNode False() { return getToken(CPP14Parser.False, 0); }
		public TerminalNode True() { return getToken(CPP14Parser.True, 0); }
		public BooleanliteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_booleanliteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBooleanliteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBooleanliteral(this);
		}
	}

	public final BooleanliteralContext booleanliteral() throws RecognitionException {
		BooleanliteralContext _localctx = new BooleanliteralContext(_ctx, getState());
		enterRule(_localctx, 430, RULE_booleanliteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2638);
			_la = _input.LA(1);
			if ( !(_la==False || _la==True) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PointerliteralContext extends ParserRuleContext {
		public TerminalNode Nullptr() { return getToken(CPP14Parser.Nullptr, 0); }
		public PointerliteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pointerliteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPointerliteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPointerliteral(this);
		}
	}

	public final PointerliteralContext pointerliteral() throws RecognitionException {
		PointerliteralContext _localctx = new PointerliteralContext(_ctx, getState());
		enterRule(_localctx, 432, RULE_pointerliteral);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2640);
			match(Nullptr);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UserdefinedliteralContext extends ParserRuleContext {
		public TerminalNode Userdefinedintegerliteral() { return getToken(CPP14Parser.Userdefinedintegerliteral, 0); }
		public TerminalNode Userdefinedfloatingliteral() { return getToken(CPP14Parser.Userdefinedfloatingliteral, 0); }
		public TerminalNode Userdefinedstringliteral() { return getToken(CPP14Parser.Userdefinedstringliteral, 0); }
		public TerminalNode Userdefinedcharacterliteral() { return getToken(CPP14Parser.Userdefinedcharacterliteral, 0); }
		public UserdefinedliteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_userdefinedliteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUserdefinedliteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUserdefinedliteral(this);
		}
	}

	public final UserdefinedliteralContext userdefinedliteral() throws RecognitionException {
		UserdefinedliteralContext _localctx = new UserdefinedliteralContext(_ctx, getState());
		enterRule(_localctx, 434, RULE_userdefinedliteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(2642);
			_la = _input.LA(1);
			if ( !((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 15L) != 0) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 5:
			return nestednamespecifier_sempred((NestednamespecifierContext)_localctx, predIndex);
		case 10:
			return capturelist_sempred((CapturelistContext)_localctx, predIndex);
		case 15:
			return postfixexpression_sempred((PostfixexpressionContext)_localctx, predIndex);
		case 26:
			return noptrnewdeclarator_sempred((NoptrnewdeclaratorContext)_localctx, predIndex);
		case 31:
			return pmexpression_sempred((PmexpressionContext)_localctx, predIndex);
		case 32:
			return multiplicativeexpression_sempred((MultiplicativeexpressionContext)_localctx, predIndex);
		case 33:
			return additiveexpression_sempred((AdditiveexpressionContext)_localctx, predIndex);
		case 34:
			return shiftexpression_sempred((ShiftexpressionContext)_localctx, predIndex);
		case 36:
			return restricttypelist_sempred((RestricttypelistContext)_localctx, predIndex);
		case 39:
			return relationalexpression_sempred((RelationalexpressionContext)_localctx, predIndex);
		case 40:
			return equalityexpression_sempred((EqualityexpressionContext)_localctx, predIndex);
		case 41:
			return andexpression_sempred((AndexpressionContext)_localctx, predIndex);
		case 42:
			return exclusiveorexpression_sempred((ExclusiveorexpressionContext)_localctx, predIndex);
		case 43:
			return inclusiveorexpression_sempred((InclusiveorexpressionContext)_localctx, predIndex);
		case 44:
			return logicalandexpression_sempred((LogicalandexpressionContext)_localctx, predIndex);
		case 46:
			return logicalorexpression_sempred((LogicalorexpressionContext)_localctx, predIndex);
		case 51:
			return expression_sempred((ExpressionContext)_localctx, predIndex);
		case 57:
			return statementseq_sempred((StatementseqContext)_localctx, predIndex);
		case 66:
			return declarationseq_sempred((DeclarationseqContext)_localctx, predIndex);
		case 94:
			return enumeratorlist_sempred((EnumeratorlistContext)_localctx, predIndex);
		case 112:
			return attributespecifierseq_sempred((AttributespecifierseqContext)_localctx, predIndex);
		case 115:
			return attributelist_sempred((AttributelistContext)_localctx, predIndex);
		case 121:
			return balancedtokenseq_sempred((BalancedtokenseqContext)_localctx, predIndex);
		case 123:
			return initdeclaratorlist_sempred((InitdeclaratorlistContext)_localctx, predIndex);
		case 127:
			return noptrdeclarator_sempred((NoptrdeclaratorContext)_localctx, predIndex);
		case 138:
			return noptrabstractdeclarator_sempred((NoptrabstractdeclaratorContext)_localctx, predIndex);
		case 140:
			return noptrabstractpackdeclarator_sempred((NoptrabstractpackdeclaratorContext)_localctx, predIndex);
		case 142:
			return parameterdeclarationlist_sempred((ParameterdeclarationlistContext)_localctx, predIndex);
		case 149:
			return initializerlist_sempred((InitializerlistContext)_localctx, predIndex);
		case 166:
			return memberdeclaratorlist_sempred((MemberdeclaratorlistContext)_localctx, predIndex);
		case 168:
			return virtspecifierseq_sempred((VirtspecifierseqContext)_localctx, predIndex);
		case 172:
			return basespecifierlist_sempred((BasespecifierlistContext)_localctx, predIndex);
		case 187:
			return templateparameterlist_sempred((TemplateparameterlistContext)_localctx, predIndex);
		case 193:
			return templateargumentlist_sempred((TemplateargumentlistContext)_localctx, predIndex);
		case 206:
			return typeidlist_sempred((TypeidlistContext)_localctx, predIndex);
		case 214:
			return stringliteralseq_sempred((StringliteralseqContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean nestednamespecifier_sempred(NestednamespecifierContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 2);
		case 1:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean capturelist_sempred(CapturelistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 2:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean postfixexpression_sempred(PostfixexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 3:
			return precpred(_ctx, 19);
		case 4:
			return precpred(_ctx, 18);
		case 5:
			return precpred(_ctx, 17);
		case 6:
			return precpred(_ctx, 12);
		case 7:
			return precpred(_ctx, 11);
		case 8:
			return precpred(_ctx, 10);
		case 9:
			return precpred(_ctx, 9);
		case 10:
			return precpred(_ctx, 8);
		case 11:
			return precpred(_ctx, 7);
		}
		return true;
	}
	private boolean noptrnewdeclarator_sempred(NoptrnewdeclaratorContext _localctx, int predIndex) {
		switch (predIndex) {
		case 12:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean pmexpression_sempred(PmexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 13:
			return precpred(_ctx, 2);
		case 14:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean multiplicativeexpression_sempred(MultiplicativeexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 15:
			return precpred(_ctx, 4);
		case 16:
			return precpred(_ctx, 3);
		case 17:
			return precpred(_ctx, 2);
		case 18:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean additiveexpression_sempred(AdditiveexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 19:
			return precpred(_ctx, 2);
		case 20:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean shiftexpression_sempred(ShiftexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 21:
			return precpred(_ctx, 2);
		case 22:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean restricttypelist_sempred(RestricttypelistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 23:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean relationalexpression_sempred(RelationalexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 24:
			return precpred(_ctx, 3);
		case 25:
			return precpred(_ctx, 2);
		case 26:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean equalityexpression_sempred(EqualityexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 27:
			return precpred(_ctx, 2);
		case 28:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean andexpression_sempred(AndexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 29:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean exclusiveorexpression_sempred(ExclusiveorexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 30:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean inclusiveorexpression_sempred(InclusiveorexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 31:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean logicalandexpression_sempred(LogicalandexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 32:
			return precpred(_ctx, 2);
		case 33:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean logicalorexpression_sempred(LogicalorexpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 34:
			return precpred(_ctx, 2);
		case 35:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 36:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean statementseq_sempred(StatementseqContext _localctx, int predIndex) {
		switch (predIndex) {
		case 37:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean declarationseq_sempred(DeclarationseqContext _localctx, int predIndex) {
		switch (predIndex) {
		case 38:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean enumeratorlist_sempred(EnumeratorlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 39:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean attributespecifierseq_sempred(AttributespecifierseqContext _localctx, int predIndex) {
		switch (predIndex) {
		case 40:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean attributelist_sempred(AttributelistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 41:
			return precpred(_ctx, 3);
		case 42:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean balancedtokenseq_sempred(BalancedtokenseqContext _localctx, int predIndex) {
		switch (predIndex) {
		case 43:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean initdeclaratorlist_sempred(InitdeclaratorlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 44:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean noptrdeclarator_sempred(NoptrdeclaratorContext _localctx, int predIndex) {
		switch (predIndex) {
		case 45:
			return precpred(_ctx, 3);
		case 46:
			return precpred(_ctx, 2);
		}
		return true;
	}
	private boolean noptrabstractdeclarator_sempred(NoptrabstractdeclaratorContext _localctx, int predIndex) {
		switch (predIndex) {
		case 47:
			return precpred(_ctx, 5);
		case 48:
			return precpred(_ctx, 3);
		}
		return true;
	}
	private boolean noptrabstractpackdeclarator_sempred(NoptrabstractpackdeclaratorContext _localctx, int predIndex) {
		switch (predIndex) {
		case 49:
			return precpred(_ctx, 3);
		case 50:
			return precpred(_ctx, 2);
		}
		return true;
	}
	private boolean parameterdeclarationlist_sempred(ParameterdeclarationlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 51:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean initializerlist_sempred(InitializerlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 52:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean memberdeclaratorlist_sempred(MemberdeclaratorlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 53:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean virtspecifierseq_sempred(VirtspecifierseqContext _localctx, int predIndex) {
		switch (predIndex) {
		case 54:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean basespecifierlist_sempred(BasespecifierlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 55:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean templateparameterlist_sempred(TemplateparameterlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 56:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean templateargumentlist_sempred(TemplateargumentlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 57:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean typeidlist_sempred(TypeidlistContext _localctx, int predIndex) {
		switch (predIndex) {
		case 58:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean stringliteralseq_sempred(StringliteralseqContext _localctx, int predIndex) {
		switch (predIndex) {
		case 59:
			return precpred(_ctx, 1);
		}
		return true;
	}

	private static final String _serializedATNSegment0 =
		"\u0004\u0001\u009b\u0a55\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
		"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
		"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
		"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
		"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
		"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
		"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
		"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+
		"\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+
		"\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+
		"\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+
		"\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+
		"\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+
		",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+
		"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
		"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
		";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+
		"@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+
		"E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+
		"J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+
		"O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+
		"T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+
		"Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+
		"^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+
		"c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+
		"h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+
		"m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+
		"r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+
		"w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007"+
		"|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007"+
		"\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007"+
		"\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007"+
		"\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007"+
		"\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007"+
		"\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007"+
		"\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007"+
		"\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007"+
		"\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007"+
		"\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007"+
		"\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007"+
		"\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007"+
		"\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007"+
		"\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007"+
		"\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007"+
		"\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007"+
		"\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007"+
		"\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007"+
		"\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007"+
		"\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007"+
		"\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007"+
		"\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be\u0002\u00bf\u0007"+
		"\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1\u0002\u00c2\u0007"+
		"\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4\u0002\u00c5\u0007"+
		"\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7\u0002\u00c8\u0007"+
		"\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca\u0002\u00cb\u0007"+
		"\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd\u0002\u00ce\u0007"+
		"\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0\u0002\u00d1\u0007"+
		"\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3\u0002\u00d4\u0007"+
		"\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6\u0002\u00d7\u0007"+
		"\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9\u0001\u0000\u0003"+
		"\u0000\u01b6\b\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+
		"\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003"+
		"\u0001\u01c2\b\u0001\u0001\u0002\u0001\u0002\u0003\u0002\u01c6\b\u0002"+
		"\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u01d1\b\u0003\u0001\u0004"+
		"\u0001\u0004\u0003\u0004\u01d5\b\u0004\u0001\u0004\u0001\u0004\u0001\u0005"+
		"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+
		"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u01e4\b\u0005"+
		"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005"+
		"\u01eb\b\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u01f0\b"+
		"\u0005\n\u0005\f\u0005\u01f3\t\u0005\u0001\u0006\u0001\u0006\u0003\u0006"+
		"\u01f7\b\u0006\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0003\u0007"+
		"\u01fd\b\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\b"+
		"\u0001\b\u0001\b\u0003\b\u0207\b\b\u0001\t\u0001\t\u0001\n\u0001\n\u0001"+
		"\n\u0003\n\u020e\b\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u0214\b\n"+
		"\u0005\n\u0216\b\n\n\n\f\n\u0219\t\n\u0001\u000b\u0001\u000b\u0003\u000b"+
		"\u021d\b\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0003\f\u0223\b\f\u0001"+
		"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u022a\b\r\u0001\u000e\u0001"+
		"\u000e\u0001\u000e\u0001\u000e\u0003\u000e\u0230\b\u000e\u0001\u000e\u0003"+
		"\u000e\u0233\b\u000e\u0001\u000e\u0003\u000e\u0236\b\u000e\u0001\u000e"+
		"\u0003\u000e\u0239\b\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0003\u000f\u0240\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0003\u000f\u0247\b\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0003\u000f\u024d\b\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0003\u000f\u027c\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u028b\b\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0291\b\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0297\b\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f"+
		"\u02a4\b\u000f\n\u000f\f\u000f\u02a7\t\u000f\u0001\u0010\u0001\u0010\u0001"+
		"\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0013\u0003\u0013\u02b0"+
		"\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+
		"\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+
		"\u0013\u0001\u0013\u0003\u0013\u02bf\b\u0013\u0001\u0013\u0001\u0013\u0001"+
		"\u0013\u0001\u0013\u0003\u0013\u02c5\b\u0013\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0003\u0014\u02e3\b\u0014\u0001\u0015\u0001\u0015\u0001"+
		"\u0016\u0003\u0016\u02e8\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u02ec"+
		"\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u02f0\b\u0016\u0001\u0016"+
		"\u0003\u0016\u02f3\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u02f7\b"+
		"\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u02fd"+
		"\b\u0016\u0003\u0016\u02ff\b\u0016\u0001\u0017\u0001\u0017\u0001\u0017"+
		"\u0001\u0017\u0001\u0018\u0001\u0018\u0003\u0018\u0307\b\u0018\u0001\u0019"+
		"\u0001\u0019\u0003\u0019\u030b\b\u0019\u0001\u0019\u0003\u0019\u030e\b"+
		"\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003"+
		"\u001a\u0315\b\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+
		"\u001a\u0003\u001a\u031c\b\u001a\u0005\u001a\u031e\b\u001a\n\u001a\f\u001a"+
		"\u0321\t\u001a\u0001\u001b\u0001\u001b\u0003\u001b\u0325\b\u001b\u0001"+
		"\u001b\u0001\u001b\u0003\u001b\u0329\b\u001b\u0001\u001c\u0003\u001c\u032c"+
		"\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u0331\b\u001c"+
		"\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u0337\b\u001c"+
		"\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001e"+
		"\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e"+
		"\u0344\b\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+
		"\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0005\u001f\u034f\b\u001f"+
		"\n\u001f\f\u001f\u0352\t\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+
		" \u0001 \u0001 \u0001 \u0003 \u035d\b \u0001 \u0001 \u0001 \u0001 \u0001"+
		" \u0001 \u0001 \u0005 \u0366\b \n \f \u0369\t \u0001!\u0001!\u0001!\u0001"+
		"!\u0001!\u0001!\u0001!\u0001!\u0001!\u0005!\u0374\b!\n!\f!\u0377\t!\u0001"+
		"\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+
		"\"\u0005\"\u0383\b\"\n\"\f\"\u0386\t\"\u0001#\u0001#\u0001$\u0001$\u0001"+
		"$\u0001$\u0001$\u0005$\u038f\b$\n$\f$\u0392\t$\u0001%\u0001%\u0001%\u0001"+
		"%\u0001%\u0003%\u0399\b%\u0001&\u0001&\u0003&\u039d\b&\u0001\'\u0001\'"+
		"\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+
		"\'\u0001\'\u0005\'\u03ab\b\'\n\'\f\'\u03ae\t\'\u0001(\u0001(\u0001(\u0001"+
		"(\u0001(\u0001(\u0001(\u0001(\u0001(\u0005(\u03b9\b(\n(\f(\u03bc\t(\u0001"+
		")\u0001)\u0001)\u0001)\u0001)\u0001)\u0005)\u03c4\b)\n)\f)\u03c7\t)\u0001"+
		"*\u0001*\u0001*\u0001*\u0001*\u0001*\u0005*\u03cf\b*\n*\f*\u03d2\t*\u0001"+
		"+\u0001+\u0001+\u0001+\u0001+\u0001+\u0005+\u03da\b+\n+\f+\u03dd\t+\u0001"+
		",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0005"+
		",\u03e9\b,\n,\f,\u03ec\t,\u0001-\u0001-\u0001.\u0001.\u0001.\u0001.\u0001"+
		".\u0001.\u0001.\u0001.\u0001.\u0001.\u0005.\u03fa\b.\n.\f.\u03fd\t.\u0001"+
		"/\u0001/\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00030\u0408"+
		"\b0\u00011\u00011\u00011\u00011\u00011\u00011\u00031\u0410\b1\u00012\u0001"+
		"2\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u0003"+
		"2\u041d\b2\u00013\u00013\u00013\u00013\u00013\u00013\u00053\u0425\b3\n"+
		"3\f3\u0428\t3\u00014\u00014\u00015\u00015\u00035\u042e\b5\u00015\u0001"+
		"5\u00035\u0432\b5\u00015\u00015\u00035\u0436\b5\u00015\u00015\u00035\u043a"+
		"\b5\u00015\u00015\u00035\u043e\b5\u00015\u00015\u00015\u00035\u0443\b"+
		"5\u00015\u00015\u00035\u0447\b5\u00016\u00036\u044a\b6\u00016\u00016\u0001"+
		"6\u00016\u00036\u0450\b6\u00016\u00016\u00016\u00016\u00016\u00016\u0003"+
		"6\u0458\b6\u00016\u00016\u00016\u00036\u045d\b6\u00017\u00037\u0460\b"+
		"7\u00017\u00017\u00018\u00018\u00038\u0466\b8\u00018\u00018\u00038\u046a"+
		"\b8\u00019\u00019\u00019\u00019\u00019\u00059\u0471\b9\n9\f9\u0474\t9"+
		"\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001"+
		":\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001"+
		":\u0003:\u048a\b:\u0001;\u0001;\u0003;\u048e\b;\u0001;\u0001;\u0001;\u0001"+
		";\u0001;\u0001;\u0003;\u0496\b;\u0001;\u0001;\u0001;\u0001;\u0003;\u049c"+
		"\b;\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001"+
		"<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0003<\u04b0"+
		"\b<\u0001<\u0001<\u0003<\u04b4\b<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001"+
		"<\u0001<\u0001<\u0001<\u0001<\u0001<\u0003<\u04c1\b<\u0001=\u0001=\u0003"+
		"=\u04c5\b=\u0001>\u0003>\u04c8\b>\u0001>\u0001>\u0001>\u0001?\u0001?\u0003"+
		"?\u04cf\b?\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0003@\u04d7\b@\u0001"+
		"@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0003@\u04e1\b@\u0001"+
		"A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0005B\u04ea\bB\nB\fB\u04ed"+
		"\tB\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0003"+
		"C\u04f8\bC\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0003"+
		"D\u0502\bD\u0001E\u0001E\u0001E\u0003E\u0507\bE\u0001E\u0001E\u0001E\u0001"+
		"E\u0001F\u0003F\u050e\bF\u0001F\u0003F\u0511\bF\u0001F\u0001F\u0001F\u0003"+
		"F\u0516\bF\u0001F\u0001F\u0001F\u0003F\u051b\bF\u0001G\u0001G\u0001G\u0001"+
		"G\u0001G\u0001G\u0001G\u0001G\u0001H\u0001H\u0001I\u0001I\u0001I\u0001"+
		"J\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0530\bJ\u0001K\u0001K\u0003"+
		"K\u0534\bK\u0001K\u0001K\u0001K\u0003K\u0539\bK\u0001L\u0001L\u0001M\u0001"+
		"M\u0001N\u0001N\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001"+
		"P\u0003P\u0549\bP\u0001Q\u0001Q\u0001Q\u0001Q\u0003Q\u054f\bQ\u0001R\u0001"+
		"R\u0003R\u0553\bR\u0001R\u0001R\u0001R\u0003R\u0558\bR\u0001S\u0001S\u0003"+
		"S\u055c\bS\u0001S\u0001S\u0001S\u0003S\u0561\bS\u0001T\u0003T\u0564\b"+
		"T\u0001T\u0003T\u0567\bT\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+
		"T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+
		"T\u0001T\u0001T\u0001T\u0001T\u0003T\u057e\bT\u0001U\u0001U\u0001U\u0001"+
		"U\u0003U\u0584\bU\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001"+
		"V\u0001V\u0003V\u058f\bV\u0001W\u0001W\u0003W\u0593\bW\u0001W\u0003W\u0596"+
		"\bW\u0001W\u0001W\u0001W\u0003W\u059b\bW\u0001W\u0001W\u0001W\u0001W\u0001"+
		"W\u0001W\u0003W\u05a3\bW\u0001W\u0001W\u0001W\u0001W\u0003W\u05a9\bW\u0001"+
		"W\u0003W\u05ac\bW\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0003Y\u05b3\bY\u0001"+
		"Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0003Y\u05bd\bY\u0001"+
		"Z\u0001Z\u0003Z\u05c1\bZ\u0001Z\u0003Z\u05c4\bZ\u0001Z\u0003Z\u05c7\b"+
		"Z\u0001Z\u0001Z\u0003Z\u05cb\bZ\u0001Z\u0001Z\u0001Z\u0003Z\u05d0\bZ\u0003"+
		"Z\u05d2\bZ\u0001[\u0001[\u0003[\u05d6\b[\u0001[\u0001[\u0003[\u05da\b"+
		"[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0003\\\u05e3"+
		"\b\\\u0001]\u0001]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0005"+
		"^\u05ee\b^\n^\f^\u05f1\t^\u0001_\u0001_\u0001_\u0001_\u0001_\u0003_\u05f8"+
		"\b_\u0001`\u0001`\u0001a\u0001a\u0003a\u05fe\ba\u0001b\u0001b\u0001c\u0001"+
		"c\u0003c\u0604\bc\u0001d\u0001d\u0003d\u0608\bd\u0001e\u0003e\u060b\b"+
		"e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001f\u0003f\u0614\bf\u0001"+
		"f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001g\u0003g\u061d\bg\u0001g\u0001"+
		"g\u0001g\u0001g\u0001g\u0001h\u0003h\u0625\bh\u0001i\u0001i\u0001j\u0001"+
		"j\u0001j\u0001j\u0001j\u0001j\u0001k\u0003k\u0630\bk\u0001k\u0001k\u0001"+
		"l\u0001l\u0003l\u0636\bl\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001"+
		"l\u0001l\u0001l\u0003l\u0641\bl\u0001m\u0003m\u0644\bm\u0001m\u0001m\u0001"+
		"m\u0003m\u0649\bm\u0001m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001n\u0001"+
		"n\u0001n\u0001o\u0001o\u0001o\u0001o\u0003o\u0658\bo\u0001o\u0001o\u0001"+
		"o\u0001o\u0003o\u065e\bo\u0001p\u0001p\u0001p\u0001p\u0001p\u0005p\u0665"+
		"\bp\np\fp\u0668\tp\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0003"+
		"q\u0671\bq\u0001r\u0001r\u0001r\u0001r\u0003r\u0677\br\u0001r\u0001r\u0001"+
		"r\u0001r\u0001r\u0001r\u0003r\u067f\br\u0001r\u0001r\u0003r\u0683\br\u0001"+
		"s\u0001s\u0003s\u0687\bs\u0001s\u0001s\u0001s\u0003s\u068c\bs\u0001s\u0001"+
		"s\u0001s\u0003s\u0691\bs\u0001s\u0001s\u0001s\u0001s\u0001s\u0005s\u0698"+
		"\bs\ns\fs\u069b\ts\u0001t\u0001t\u0003t\u069f\bt\u0001u\u0001u\u0003u"+
		"\u06a3\bu\u0001v\u0001v\u0001v\u0001v\u0001w\u0001w\u0001x\u0001x\u0001"+
		"x\u0001x\u0001y\u0001y\u0003y\u06b1\by\u0001y\u0001y\u0005y\u06b5\by\n"+
		"y\fy\u06b8\ty\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z"+
		"\u0001z\u0001z\u0001z\u0001z\u0001z\u0004z\u06c7\bz\u000bz\fz\u06c8\u0003"+
		"z\u06cb\bz\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0005{\u06d3\b{\n"+
		"{\f{\u06d6\t{\u0001|\u0001|\u0003|\u06da\b|\u0001}\u0001}\u0001}\u0001"+
		"}\u0001}\u0003}\u06e1\b}\u0001~\u0001~\u0001~\u0001~\u0003~\u06e7\b~\u0001"+
		"\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u06ec\b\u007f\u0001\u007f\u0001"+
		"\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u06f2\b\u007f\u0001\u007f\u0001"+
		"\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u06f9\b\u007f\u0001"+
		"\u007f\u0001\u007f\u0003\u007f\u06fd\b\u007f\u0005\u007f\u06ff\b\u007f"+
		"\n\u007f\f\u007f\u0702\t\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0001"+
		"\u0080\u0003\u0080\u0708\b\u0080\u0001\u0080\u0003\u0080\u070b\b\u0080"+
		"\u0001\u0080\u0003\u0080\u070e\b\u0080\u0001\u0080\u0003\u0080\u0711\b"+
		"\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0003\u0081\u0716\b\u0081\u0001"+
		"\u0082\u0001\u0082\u0003\u0082\u071a\b\u0082\u0001\u0082\u0003\u0082\u071d"+
		"\b\u0082\u0001\u0082\u0001\u0082\u0003\u0082\u0721\b\u0082\u0001\u0082"+
		"\u0001\u0082\u0003\u0082\u0725\b\u0082\u0001\u0082\u0001\u0082\u0001\u0082"+
		"\u0003\u0082\u072a\b\u0082\u0001\u0082\u0003\u0082\u072d\b\u0082\u0003"+
		"\u0082\u072f\b\u0082\u0001\u0083\u0001\u0083\u0003\u0083\u0733\b\u0083"+
		"\u0001\u0084\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0086\u0003\u0086"+
		"\u073a\b\u0086\u0001\u0086\u0001\u0086\u0001\u0087\u0001\u0087\u0003\u0087"+
		"\u0740\b\u0087\u0001\u0088\u0001\u0088\u0003\u0088\u0744\b\u0088\u0001"+
		"\u0088\u0001\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u074a\b\u0088\u0001"+
		"\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u074f\b\u0089\u0003\u0089\u0751"+
		"\b\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u0757"+
		"\b\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u075b\b\u008a\u0001\u008a"+
		"\u0001\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u0761\b\u008a\u0001\u008a"+
		"\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u0768\b\u008a"+
		"\u0001\u008a\u0001\u008a\u0003\u008a\u076c\b\u008a\u0005\u008a\u076e\b"+
		"\u008a\n\u008a\f\u008a\u0771\t\u008a\u0001\u008b\u0001\u008b\u0001\u008b"+
		"\u0001\u008b\u0003\u008b\u0777\b\u008b\u0001\u008c\u0001\u008c\u0001\u008c"+
		"\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0003\u008c"+
		"\u0781\b\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u0785\b\u008c\u0005"+
		"\u008c\u0787\b\u008c\n\u008c\f\u008c\u078a\t\u008c\u0001\u008d\u0003\u008d"+
		"\u078d\b\u008d\u0001\u008d\u0003\u008d\u0790\b\u008d\u0001\u008d\u0001"+
		"\u008d\u0001\u008d\u0001\u008d\u0003\u008d\u0796\b\u008d\u0001\u008e\u0001"+
		"\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0005\u008e\u079e"+
		"\b\u008e\n\u008e\f\u008e\u07a1\t\u008e\u0001\u008f\u0003\u008f\u07a4\b"+
		"\u008f\u0001\u008f\u0003\u008f\u07a7\b\u008f\u0001\u008f\u0001\u008f\u0001"+
		"\u008f\u0001\u008f\u0003\u008f\u07ad\b\u008f\u0001\u008f\u0001\u008f\u0001"+
		"\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u07b5\b\u008f\u0001"+
		"\u008f\u0001\u008f\u0003\u008f\u07b9\b\u008f\u0001\u008f\u0003\u008f\u07bc"+
		"\b\u008f\u0001\u008f\u0001\u008f\u0003\u008f\u07c0\b\u008f\u0001\u008f"+
		"\u0001\u008f\u0001\u008f\u0003\u008f\u07c5\b\u008f\u0001\u0090\u0003\u0090"+
		"\u07c8\b\u0090\u0001\u0090\u0003\u0090\u07cb\b\u0090\u0001\u0090\u0001"+
		"\u0090\u0003\u0090\u07cf\b\u0090\u0001\u0090\u0001\u0090\u0001\u0091\u0003"+
		"\u0091\u07d4\b\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001"+
		"\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u07de\b\u0091\u0001"+
		"\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u07e5"+
		"\b\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0003\u0093\u07ea\b\u0093"+
		"\u0001\u0094\u0001\u0094\u0003\u0094\u07ee\b\u0094\u0001\u0095\u0001\u0095"+
		"\u0001\u0095\u0003\u0095\u07f3\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095"+
		"\u0001\u0095\u0003\u0095\u07f9\b\u0095\u0005\u0095\u07fb\b\u0095\n\u0095"+
		"\f\u0095\u07fe\t\u0095\u0001\u0096\u0001\u0096\u0001\u0096\u0003\u0096"+
		"\u0803\b\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0003\u0096"+
		"\u0809\b\u0096\u0001\u0097\u0001\u0097\u0003\u0097\u080d\b\u0097\u0001"+
		"\u0098\u0001\u0098\u0001\u0098\u0003\u0098\u0812\b\u0098\u0001\u0098\u0001"+
		"\u0098\u0003\u0098\u0816\b\u0098\u0001\u0099\u0001\u0099\u0003\u0099\u081a"+
		"\b\u0099\u0001\u009a\u0001\u009a\u0001\u009a\u0003\u009a\u081f\b\u009a"+
		"\u0001\u009a\u0001\u009a\u0003\u009a\u0823\b\u009a\u0001\u009b\u0001\u009b"+
		"\u0003\u009b\u0827\b\u009b\u0001\u009b\u0001\u009b\u0001\u009c\u0001\u009c"+
		"\u0001\u009c\u0003\u009c\u082e\b\u009c\u0001\u009c\u0001\u009c\u0001\u009d"+
		"\u0001\u009d\u0001\u009d\u0003\u009d\u0835\b\u009d\u0001\u009d\u0001\u009d"+
		"\u0001\u009e\u0001\u009e\u0003\u009e\u083b\b\u009e\u0001\u009e\u0001\u009e"+
		"\u0003\u009e\u083f\b\u009e\u0001\u009e\u0001\u009e\u0003\u009e\u0843\b"+
		"\u009e\u0003\u009e\u0845\b\u009e\u0001\u009f\u0001\u009f\u0003\u009f\u0849"+
		"\b\u009f\u0001\u009f\u0001\u009f\u0003\u009f\u084d\b\u009f\u0001\u009f"+
		"\u0001\u009f\u0001\u009f\u0001\u009f\u0003\u009f\u0853\b\u009f\u0001\u009f"+
		"\u0001\u009f\u0003\u009f\u0857\b\u009f\u0001\u00a0\u0003\u00a0\u085a\b"+
		"\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001"+
		"\u00a2\u0001\u00a3\u0003\u00a3\u0863\b\u00a3\u0001\u00a3\u0001\u00a3\u0001"+
		"\u00a4\u0001\u00a4\u0003\u00a4\u0869\b\u00a4\u0001\u00a4\u0001\u00a4\u0001"+
		"\u00a4\u0003\u00a4\u086e\b\u00a4\u0003\u00a4\u0870\b\u00a4\u0001\u00a5"+
		"\u0003\u00a5\u0873\b\u00a5\u0001\u00a5\u0003\u00a5\u0876\b\u00a5\u0001"+
		"\u00a5\u0003\u00a5\u0879\b\u00a5\u0001\u00a5\u0003\u00a5\u087c\b\u00a5"+
		"\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+
		"\u0001\u00a5\u0003\u00a5\u0885\b\u00a5\u0001\u00a6\u0001\u00a6\u0001\u00a6"+
		"\u0001\u00a6\u0001\u00a6\u0001\u00a6\u0005\u00a6\u088d\b\u00a6\n\u00a6"+
		"\f\u00a6\u0890\t\u00a6\u0001\u00a7\u0001\u00a7\u0003\u00a7\u0894\b\u00a7"+
		"\u0001\u00a7\u0003\u00a7\u0897\b\u00a7\u0001\u00a7\u0001\u00a7\u0003\u00a7"+
		"\u089b\b\u00a7\u0001\u00a7\u0003\u00a7\u089e\b\u00a7\u0001\u00a7\u0003"+
		"\u00a7\u08a1\b\u00a7\u0001\u00a7\u0001\u00a7\u0003\u00a7\u08a5\b\u00a7"+
		"\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8\u0005\u00a8"+
		"\u08ac\b\u00a8\n\u00a8\f\u00a8\u08af\t\u00a8\u0001\u00a9\u0001\u00a9\u0001"+
		"\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001"+
		"\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac\u08bd\b\u00ac\u0001"+
		"\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac\u08c3\b\u00ac\u0005"+
		"\u00ac\u08c5\b\u00ac\n\u00ac\f\u00ac\u08c8\t\u00ac\u0001\u00ad\u0003\u00ad"+
		"\u08cb\b\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad\u08cf\b\u00ad\u0001"+
		"\u00ad\u0001\u00ad\u0003\u00ad\u08d3\b\u00ad\u0001\u00ad\u0001\u00ad\u0003"+
		"\u00ad\u08d7\b\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad\u08db\b\u00ad"+
		"\u0001\u00ad\u0001\u00ad\u0003\u00ad\u08df\b\u00ad\u0001\u00ae\u0003\u00ae"+
		"\u08e2\b\u00ae\u0001\u00ae\u0001\u00ae\u0003\u00ae\u08e6\b\u00ae\u0001"+
		"\u00af\u0001\u00af\u0001\u00b0\u0001\u00b0\u0001\u00b1\u0001\u00b1\u0001"+
		"\u00b1\u0001\u00b2\u0001\u00b2\u0003\u00b2\u08f1\b\u00b2\u0001\u00b3\u0001"+
		"\u00b3\u0003\u00b3\u08f5\b\u00b3\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001"+
		"\u00b5\u0001\u00b5\u0003\u00b5\u08fc\b\u00b5\u0001\u00b5\u0001\u00b5\u0003"+
		"\u00b5\u0900\b\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0003\u00b5\u0905"+
		"\b\u00b5\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0003\u00b6\u090a\b\u00b6"+
		"\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0003\u00b6"+
		"\u0911\b\u00b6\u0001\u00b7\u0001\u00b7\u0003\u00b7\u0915\b\u00b7\u0001"+
		"\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0001"+
		"\u00b9\u0001\u00b9\u0003\u00b9\u091f\b\u00b9\u0001\u00ba\u0001\u00ba\u0001"+
		"\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00bb\u0001\u00bb\u0001"+
		"\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb\u0005\u00bb\u092d\b\u00bb\n"+
		"\u00bb\f\u00bb\u0930\t\u00bb\u0001\u00bc\u0001\u00bc\u0003\u00bc\u0934"+
		"\b\u00bc\u0001\u00bd\u0001\u00bd\u0003\u00bd\u0938\b\u00bd\u0001\u00bd"+
		"\u0003\u00bd\u093b\b\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u093f\b"+
		"\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u0945"+
		"\b\u00bd\u0001\u00bd\u0003\u00bd\u0948\b\u00bd\u0001\u00bd\u0001\u00bd"+
		"\u0003\u00bd\u094c\b\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+
		"\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u0956\b\u00bd"+
		"\u0001\u00bd\u0003\u00bd\u0959\b\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+
		"\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u0961\b\u00bd\u0001\u00bd"+
		"\u0001\u00bd\u0001\u00bd\u0003\u00bd\u0966\b\u00bd\u0001\u00be\u0001\u00be"+
		"\u0001\u00be\u0003\u00be\u096b\b\u00be\u0001\u00be\u0001\u00be\u0001\u00bf"+
		"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u0973\b\u00bf\u0001\u00bf"+
		"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u097a\b\u00bf"+
		"\u0001\u00bf\u0001\u00bf\u0003\u00bf\u097e\b\u00bf\u0001\u00c0\u0001\u00c0"+
		"\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0003\u00c1\u0985\b\u00c1\u0001\u00c1"+
		"\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0003\u00c1\u098b\b\u00c1\u0005\u00c1"+
		"\u098d\b\u00c1\n\u00c1\f\u00c1\u0990\t\u00c1\u0001\u00c2\u0001\u00c2\u0001"+
		"\u00c2\u0003\u00c2\u0995\b\u00c2\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001"+
		"\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u099e\b\u00c3\u0001"+
		"\u00c3\u0001\u00c3\u0003\u00c3\u09a2\b\u00c3\u0001\u00c4\u0003\u00c4\u09a5"+
		"\b\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c5\u0001\u00c5\u0001"+
		"\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0001"+
		"\u00c6\u0001\u00c7\u0001\u00c7\u0003\u00c7\u09b5\b\u00c7\u0001\u00c7\u0001"+
		"\u00c7\u0001\u00c7\u0001\u00c8\u0001\u00c8\u0003\u00c8\u09bc\b\u00c8\u0001"+
		"\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001"+
		"\u00ca\u0003\u00ca\u09c5\b\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+
		"\u00ca\u0003\u00ca\u09cb\b\u00ca\u0001\u00ca\u0001\u00ca\u0003\u00ca\u09cf"+
		"\b\u00ca\u0001\u00ca\u0003\u00ca\u09d2\b\u00ca\u0001\u00cb\u0001\u00cb"+
		"\u0003\u00cb\u09d6\b\u00cb\u0001\u00cc\u0001\u00cc\u0003\u00cc\u09da\b"+
		"\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0003\u00cd\u09df\b\u00cd\u0001"+
		"\u00cd\u0001\u00cd\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0003\u00ce\u09e6"+
		"\b\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0001\u00ce\u0003\u00ce\u09ec"+
		"\b\u00ce\u0005\u00ce\u09ee\b\u00ce\n\u00ce\f\u00ce\u09f1\t\u00ce\u0001"+
		"\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0003"+
		"\u00cf\u09f9\b\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d1\u0001"+
		"\u00d1\u0001\u00d1\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0001\u00d3\u0001"+
		"\u00d3\u0001\u00d3\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001"+
		"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0003\u00d4\u0a3a"+
		"\b\u00d4\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0001"+
		"\u00d5\u0001\u00d5\u0003\u00d5\u0a43\b\u00d5\u0001\u00d6\u0001\u00d6\u0001"+
		"\u00d6\u0001\u00d6\u0001\u00d6\u0005\u00d6\u0a4a\b\u00d6\n\u00d6\f\u00d6"+
		"\u0a4d\t\u00d6\u0001\u00d7\u0001\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d9"+
		"\u0001\u00d9\u0001\u00d9\u0000$\n\u0014\u001e4>@BDHNPRTVX\\fr\u0084\u00bc"+
		"\u00e0\u00e6\u00f2\u00f6\u00fe\u0114\u0118\u011c\u012a\u014c\u0150\u0158"+
		"\u0176\u0182\u019c\u01ac\u00da\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010"+
		"\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPR"+
		"TVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e"+
		"\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6"+
		"\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be"+
		"\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6"+
		"\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee"+
		"\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106"+
		"\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e"+
		"\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136"+
		"\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e"+
		"\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166"+
		"\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e"+
		"\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194\u0196"+
		"\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac\u01ae"+
		"\u01b0\u01b2\u0000\u000b\u0002\u0000``dd\u0003\u0000\u0001\u0002Z\\`b"+
		"\u0005\u0000\"\"--77==DD\u0003\u0000  **NN\u0001\u0000TY\u0002\u0000\u0014"+
		"\u0014PP\u0002\u0000\u0004\u0004``\u0002\u0000$$33\u0001\u000046\u0002"+
		"\u0000##FF\u0001\u0000\u008b\u008e\u0b84\u0000\u01b5\u0001\u0000\u0000"+
		"\u0000\u0002\u01c1\u0001\u0000\u0000\u0000\u0004\u01c5\u0001\u0000\u0000"+
		"\u0000\u0006\u01d0\u0001\u0000\u0000\u0000\b\u01d2\u0001\u0000\u0000\u0000"+
		"\n\u01e3\u0001\u0000\u0000\u0000\f\u01f4\u0001\u0000\u0000\u0000\u000e"+
		"\u01fa\u0001\u0000\u0000\u0000\u0010\u0206\u0001\u0000\u0000\u0000\u0012"+
		"\u0208\u0001\u0000\u0000\u0000\u0014\u020a\u0001\u0000\u0000\u0000\u0016"+
		"\u021c\u0001\u0000\u0000\u0000\u0018\u0222\u0001\u0000\u0000\u0000\u001a"+
		"\u0229\u0001\u0000\u0000\u0000\u001c\u022b\u0001\u0000\u0000\u0000\u001e"+
		"\u027b\u0001\u0000\u0000\u0000 \u02a8\u0001\u0000\u0000\u0000\"\u02aa"+
		"\u0001\u0000\u0000\u0000$\u02ac\u0001\u0000\u0000\u0000&\u02c4\u0001\u0000"+
		"\u0000\u0000(\u02e2\u0001\u0000\u0000\u0000*\u02e4\u0001\u0000\u0000\u0000"+
		",\u02fe\u0001\u0000\u0000\u0000.\u0300\u0001\u0000\u0000\u00000\u0304"+
		"\u0001\u0000\u0000\u00002\u030d\u0001\u0000\u0000\u00004\u030f\u0001\u0000"+
		"\u0000\u00006\u0328\u0001\u0000\u0000\u00008\u0336\u0001\u0000\u0000\u0000"+
		":\u0338\u0001\u0000\u0000\u0000<\u0343\u0001\u0000\u0000\u0000>\u0345"+
		"\u0001\u0000\u0000\u0000@\u0353\u0001\u0000\u0000\u0000B\u036a\u0001\u0000"+
		"\u0000\u0000D\u0378\u0001\u0000\u0000\u0000F\u0387\u0001\u0000\u0000\u0000"+
		"H\u0389\u0001\u0000\u0000\u0000J\u0398\u0001\u0000\u0000\u0000L\u039c"+
		"\u0001\u0000\u0000\u0000N\u039e\u0001\u0000\u0000\u0000P\u03af\u0001\u0000"+
		"\u0000\u0000R\u03bd\u0001\u0000\u0000\u0000T\u03c8\u0001\u0000\u0000\u0000"+
		"V\u03d3\u0001\u0000\u0000\u0000X\u03de\u0001\u0000\u0000\u0000Z\u03ed"+
		"\u0001\u0000\u0000\u0000\\\u03ef\u0001\u0000\u0000\u0000^\u03fe\u0001"+
		"\u0000\u0000\u0000`\u0407\u0001\u0000\u0000\u0000b\u040f\u0001\u0000\u0000"+
		"\u0000d\u041c\u0001\u0000\u0000\u0000f\u041e\u0001\u0000\u0000\u0000h"+
		"\u0429\u0001\u0000\u0000\u0000j\u0446\u0001\u0000\u0000\u0000l\u045c\u0001"+
		"\u0000\u0000\u0000n\u045f\u0001\u0000\u0000\u0000p\u0469\u0001\u0000\u0000"+
		"\u0000r\u046b\u0001\u0000\u0000\u0000t\u0489\u0001\u0000\u0000\u0000v"+
		"\u049b\u0001\u0000\u0000\u0000x\u04c0\u0001\u0000\u0000\u0000z\u04c4\u0001"+
		"\u0000\u0000\u0000|\u04c7\u0001\u0000\u0000\u0000~\u04ce\u0001\u0000\u0000"+
		"\u0000\u0080\u04e0\u0001\u0000\u0000\u0000\u0082\u04e2\u0001\u0000\u0000"+
		"\u0000\u0084\u04e4\u0001\u0000\u0000\u0000\u0086\u04f7\u0001\u0000\u0000"+
		"\u0000\u0088\u0501\u0001\u0000\u0000\u0000\u008a\u0503\u0001\u0000\u0000"+
		"\u0000\u008c\u051a\u0001\u0000\u0000\u0000\u008e\u051c\u0001\u0000\u0000"+
		"\u0000\u0090\u0524\u0001\u0000\u0000\u0000\u0092\u0526\u0001\u0000\u0000"+
		"\u0000\u0094\u052f\u0001\u0000\u0000\u0000\u0096\u0538\u0001\u0000\u0000"+
		"\u0000\u0098\u053a\u0001\u0000\u0000\u0000\u009a\u053c\u0001\u0000\u0000"+
		"\u0000\u009c\u053e\u0001\u0000\u0000\u0000\u009e\u0540\u0001\u0000\u0000"+
		"\u0000\u00a0\u0548\u0001\u0000\u0000\u0000\u00a2\u054e\u0001\u0000\u0000"+
		"\u0000\u00a4\u0557\u0001\u0000\u0000\u0000\u00a6\u0560\u0001\u0000\u0000"+
		"\u0000\u00a8\u057d\u0001\u0000\u0000\u0000\u00aa\u0583\u0001\u0000\u0000"+
		"\u0000\u00ac\u058e\u0001\u0000\u0000\u0000\u00ae\u05ab\u0001\u0000\u0000"+
		"\u0000\u00b0\u05ad\u0001\u0000\u0000\u0000\u00b2\u05bc\u0001\u0000\u0000"+
		"\u0000\u00b4\u05d1\u0001\u0000\u0000\u0000\u00b6\u05d3\u0001\u0000\u0000"+
		"\u0000\u00b8\u05e2\u0001\u0000\u0000\u0000\u00ba\u05e4\u0001\u0000\u0000"+
		"\u0000\u00bc\u05e7\u0001\u0000\u0000\u0000\u00be\u05f7\u0001\u0000\u0000"+
		"\u0000\u00c0\u05f9\u0001\u0000\u0000\u0000\u00c2\u05fd\u0001\u0000\u0000"+
		"\u0000\u00c4\u05ff\u0001\u0000\u0000\u0000\u00c6\u0603\u0001\u0000\u0000"+
		"\u0000\u00c8\u0607\u0001\u0000\u0000\u0000\u00ca\u060a\u0001\u0000\u0000"+
		"\u0000\u00cc\u0613\u0001\u0000\u0000\u0000\u00ce\u061c\u0001\u0000\u0000"+
		"\u0000\u00d0\u0624\u0001\u0000\u0000\u0000\u00d2\u0626\u0001\u0000\u0000"+
		"\u0000\u00d4\u0628\u0001\u0000\u0000\u0000\u00d6\u062f\u0001\u0000\u0000"+
		"\u0000\u00d8\u0640\u0001\u0000\u0000\u0000\u00da\u0643\u0001\u0000\u0000"+
		"\u0000\u00dc\u064d\u0001\u0000\u0000\u0000\u00de\u065d\u0001\u0000\u0000"+
		"\u0000\u00e0\u065f\u0001\u0000\u0000\u0000\u00e2\u0670\u0001\u0000\u0000"+
		"\u0000\u00e4\u0682\u0001\u0000\u0000\u0000\u00e6\u068b\u0001\u0000\u0000"+
		"\u0000\u00e8\u069c\u0001\u0000\u0000\u0000\u00ea\u06a2\u0001\u0000\u0000"+
		"\u0000\u00ec\u06a4\u0001\u0000\u0000\u0000\u00ee\u06a8\u0001\u0000\u0000"+
		"\u0000\u00f0\u06aa\u0001\u0000\u0000\u0000\u00f2\u06ae\u0001\u0000\u0000"+
		"\u0000\u00f4\u06ca\u0001\u0000\u0000\u0000\u00f6\u06cc\u0001\u0000\u0000"+
		"\u0000\u00f8\u06d7\u0001\u0000\u0000\u0000\u00fa\u06e0\u0001\u0000\u0000"+
		"\u0000\u00fc\u06e6\u0001\u0000\u0000\u0000\u00fe\u06f1\u0001\u0000\u0000"+
		"\u0000\u0100\u0703\u0001\u0000\u0000\u0000\u0102\u0712\u0001\u0000\u0000"+
		"\u0000\u0104\u072e\u0001\u0000\u0000\u0000\u0106\u0730\u0001\u0000\u0000"+
		"\u0000\u0108\u0734\u0001\u0000\u0000\u0000\u010a\u0736\u0001\u0000\u0000"+
		"\u0000\u010c\u0739\u0001\u0000\u0000\u0000\u010e\u073d\u0001\u0000\u0000"+
		"\u0000\u0110\u0749\u0001\u0000\u0000\u0000\u0112\u0750\u0001\u0000\u0000"+
		"\u0000\u0114\u0760\u0001\u0000\u0000\u0000\u0116\u0776\u0001\u0000\u0000"+
		"\u0000\u0118\u0778\u0001\u0000\u0000\u0000\u011a\u0795\u0001\u0000\u0000"+
		"\u0000\u011c\u0797\u0001\u0000\u0000\u0000\u011e\u07c4\u0001\u0000\u0000"+
		"\u0000\u0120\u07c7\u0001\u0000\u0000\u0000\u0122\u07dd\u0001\u0000\u0000"+
		"\u0000\u0124\u07e4\u0001\u0000\u0000\u0000\u0126\u07e9\u0001\u0000\u0000"+
		"\u0000\u0128\u07ed\u0001\u0000\u0000\u0000\u012a\u07ef\u0001\u0000\u0000"+
		"\u0000\u012c\u0808\u0001\u0000\u0000\u0000\u012e\u080c\u0001\u0000\u0000"+
		"\u0000\u0130\u080e\u0001\u0000\u0000\u0000\u0132\u0817\u0001\u0000\u0000"+
		"\u0000\u0134\u081b\u0001\u0000\u0000\u0000\u0136\u0824\u0001\u0000\u0000"+
		"\u0000\u0138\u082a\u0001\u0000\u0000\u0000\u013a\u0831\u0001\u0000\u0000"+
		"\u0000\u013c\u0844\u0001\u0000\u0000\u0000\u013e\u0856\u0001\u0000\u0000"+
		"\u0000\u0140\u0859\u0001\u0000\u0000\u0000\u0142\u085d\u0001\u0000\u0000"+
		"\u0000\u0144\u085f\u0001\u0000\u0000\u0000\u0146\u0862\u0001\u0000\u0000"+
		"\u0000\u0148\u086f\u0001\u0000\u0000\u0000\u014a\u0884\u0001\u0000\u0000"+
		"\u0000\u014c\u0886\u0001\u0000\u0000\u0000\u014e\u08a4\u0001\u0000\u0000"+
		"\u0000\u0150\u08a6\u0001\u0000\u0000\u0000\u0152\u08b0\u0001\u0000\u0000"+
		"\u0000\u0154\u08b2\u0001\u0000\u0000\u0000\u0156\u08b6\u0001\u0000\u0000"+
		"\u0000\u0158\u08b9\u0001\u0000\u0000\u0000\u015a\u08de\u0001\u0000\u0000"+
		"\u0000\u015c\u08e5\u0001\u0000\u0000\u0000\u015e\u08e7\u0001\u0000\u0000"+
		"\u0000\u0160\u08e9\u0001\u0000\u0000\u0000\u0162\u08eb\u0001\u0000\u0000"+
		"\u0000\u0164\u08ee\u0001\u0000\u0000\u0000\u0166\u08f2\u0001\u0000\u0000"+
		"\u0000\u0168\u08f6\u0001\u0000\u0000\u0000\u016a\u0904\u0001\u0000\u0000"+
		"\u0000\u016c\u0910\u0001\u0000\u0000\u0000\u016e\u0914\u0001\u0000\u0000"+
		"\u0000\u0170\u0916\u0001\u0000\u0000\u0000\u0172\u091e\u0001\u0000\u0000"+
		"\u0000\u0174\u0920\u0001\u0000\u0000\u0000\u0176\u0926\u0001\u0000\u0000"+
		"\u0000\u0178\u0933\u0001\u0000\u0000\u0000\u017a\u0965\u0001\u0000\u0000"+
		"\u0000\u017c\u0967\u0001\u0000\u0000\u0000\u017e\u097d\u0001\u0000\u0000"+
		"\u0000\u0180\u097f\u0001\u0000\u0000\u0000\u0182\u0981\u0001\u0000\u0000"+
		"\u0000\u0184\u0994\u0001\u0000\u0000\u0000\u0186\u09a1\u0001\u0000\u0000"+
		"\u0000\u0188\u09a4\u0001\u0000\u0000\u0000\u018a\u09a9\u0001\u0000\u0000"+
		"\u0000\u018c\u09ae\u0001\u0000\u0000\u0000\u018e\u09b2\u0001\u0000\u0000"+
		"\u0000\u0190\u09b9\u0001\u0000\u0000\u0000\u0192\u09bd\u0001\u0000\u0000"+
		"\u0000\u0194\u09d1\u0001\u0000\u0000\u0000\u0196\u09d3\u0001\u0000\u0000"+
		"\u0000\u0198\u09d9\u0001\u0000\u0000\u0000\u019a\u09db\u0001\u0000\u0000"+
		"\u0000\u019c\u09e2\u0001\u0000\u0000\u0000\u019e\u09f8\u0001\u0000\u0000"+
		"\u0000\u01a0\u09fa\u0001\u0000\u0000\u0000\u01a2\u09fd\u0001\u0000\u0000"+
		"\u0000\u01a4\u0a00\u0001\u0000\u0000\u0000\u01a6\u0a03\u0001\u0000\u0000"+
		"\u0000\u01a8\u0a39\u0001\u0000\u0000\u0000\u01aa\u0a42\u0001\u0000\u0000"+
		"\u0000\u01ac\u0a44\u0001\u0000\u0000\u0000\u01ae\u0a4e\u0001\u0000\u0000"+
		"\u0000\u01b0\u0a50\u0001\u0000\u0000\u0000\u01b2\u0a52\u0001\u0000\u0000"+
		"\u0000\u01b4\u01b6\u0003\u0084B\u0000\u01b5\u01b4\u0001\u0000\u0000\u0000"+
		"\u01b5\u01b6\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000\u0000\u0000"+
		"\u01b7\u01b8\u0005\u0000\u0000\u0001\u01b8\u0001\u0001\u0000\u0000\u0000"+
		"\u01b9\u01c2\u0003\u01aa\u00d5\u0000\u01ba\u01c2\u0005C\u0000\u0000\u01bb"+
		"\u01bc\u0005T\u0000\u0000\u01bc\u01bd\u0003f3\u0000\u01bd\u01be\u0005"+
		"U\u0000\u0000\u01be\u01c2\u0001\u0000\u0000\u0000\u01bf\u01c2\u0003\u0004"+
		"\u0002\u0000\u01c0\u01c2\u0003\f\u0006\u0000\u01c1\u01b9\u0001\u0000\u0000"+
		"\u0000\u01c1\u01ba\u0001\u0000\u0000\u0000\u01c1\u01bb\u0001\u0000\u0000"+
		"\u0000\u01c1\u01bf\u0001\u0000\u0000\u0000\u01c1\u01c0\u0001\u0000\u0000"+
		"\u0000\u01c2\u0003\u0001\u0000\u0000\u0000\u01c3\u01c6\u0003\u0006\u0003"+
		"\u0000\u01c4\u01c6\u0003\b\u0004\u0000\u01c5\u01c3\u0001\u0000\u0000\u0000"+
		"\u01c5\u01c4\u0001\u0000\u0000\u0000\u01c6\u0005\u0001\u0000\u0000\u0000"+
		"\u01c7\u01d1\u0005\u0081\u0000\u0000\u01c8\u01d1\u0003\u0170\u00b8\u0000"+
		"\u01c9\u01d1\u0003\u0162\u00b1\u0000\u01ca\u01d1\u0003\u0172\u00b9\u0000"+
		"\u01cb\u01cc\u0005b\u0000\u0000\u01cc\u01d1\u0003\u012e\u0097\u0000\u01cd"+
		"\u01ce\u0005b\u0000\u0000\u01ce\u01d1\u0003\u00acV\u0000\u01cf\u01d1\u0003"+
		"\u017e\u00bf\u0000\u01d0\u01c7\u0001\u0000\u0000\u0000\u01d0\u01c8\u0001"+
		"\u0000\u0000\u0000\u01d0\u01c9\u0001\u0000\u0000\u0000\u01d0\u01ca\u0001"+
		"\u0000\u0000\u0000\u01d0\u01cb\u0001\u0000\u0000\u0000\u01d0\u01cd\u0001"+
		"\u0000\u0000\u0000\u01d0\u01cf\u0001\u0000\u0000\u0000\u01d1\u0007\u0001"+
		"\u0000\u0000\u0000\u01d2\u01d4\u0003\n\u0005\u0000\u01d3\u01d5\u0005B"+
		"\u0000\u0000\u01d4\u01d3\u0001\u0000\u0000\u0000\u01d4\u01d5\u0001\u0000"+
		"\u0000\u0000\u01d5\u01d6\u0001\u0000\u0000\u0000\u01d6\u01d7\u0003\u0006"+
		"\u0003\u0000\u01d7\t\u0001\u0000\u0000\u0000\u01d8\u01d9\u0006\u0005\uffff"+
		"\uffff\u0000\u01d9\u01e4\u0005|\u0000\u0000\u01da\u01db\u0003\u00aaU\u0000"+
		"\u01db\u01dc\u0005|\u0000\u0000\u01dc\u01e4\u0001\u0000\u0000\u0000\u01dd"+
		"\u01de\u0003\u00c2a\u0000\u01de\u01df\u0005|\u0000\u0000\u01df\u01e4\u0001"+
		"\u0000\u0000\u0000\u01e0\u01e1\u0003\u00acV\u0000\u01e1\u01e2\u0005|\u0000"+
		"\u0000\u01e2\u01e4\u0001\u0000\u0000\u0000\u01e3\u01d8\u0001\u0000\u0000"+
		"\u0000\u01e3\u01da\u0001\u0000\u0000\u0000\u01e3\u01dd\u0001\u0000\u0000"+
		"\u0000\u01e3\u01e0\u0001\u0000\u0000\u0000\u01e4\u01f1\u0001\u0000\u0000"+
		"\u0000\u01e5\u01e6\n\u0002\u0000\u0000\u01e6\u01e7\u0005\u0081\u0000\u0000"+
		"\u01e7\u01f0\u0005|\u0000\u0000\u01e8\u01ea\n\u0001\u0000\u0000\u01e9"+
		"\u01eb\u0005B\u0000\u0000\u01ea\u01e9\u0001\u0000\u0000\u0000\u01ea\u01eb"+
		"\u0001\u0000\u0000\u0000\u01eb\u01ec\u0001\u0000\u0000\u0000\u01ec\u01ed"+
		"\u0003\u017c\u00be\u0000\u01ed\u01ee\u0005|\u0000\u0000\u01ee\u01f0\u0001"+
		"\u0000\u0000\u0000\u01ef\u01e5\u0001\u0000\u0000\u0000\u01ef\u01e8\u0001"+
		"\u0000\u0000\u0000\u01f0\u01f3\u0001\u0000\u0000\u0000\u01f1\u01ef\u0001"+
		"\u0000\u0000\u0000\u01f1\u01f2\u0001\u0000\u0000\u0000\u01f2\u000b\u0001"+
		"\u0000\u0000\u0000\u01f3\u01f1\u0001\u0000\u0000\u0000\u01f4\u01f6\u0003"+
		"\u000e\u0007\u0000\u01f5\u01f7\u0003\u001c\u000e\u0000\u01f6\u01f5\u0001"+
		"\u0000\u0000\u0000\u01f6\u01f7\u0001\u0000\u0000\u0000\u01f7\u01f8\u0001"+
		"\u0000\u0000\u0000\u01f8\u01f9\u0003p8\u0000\u01f9\r\u0001\u0000\u0000"+
		"\u0000\u01fa\u01fc\u0005V\u0000\u0000\u01fb\u01fd\u0003\u0010\b\u0000"+
		"\u01fc\u01fb\u0001\u0000\u0000\u0000\u01fc\u01fd\u0001\u0000\u0000\u0000"+
		"\u01fd\u01fe\u0001\u0000\u0000\u0000\u01fe\u01ff\u0005W\u0000\u0000\u01ff"+
		"\u000f\u0001\u0000\u0000\u0000\u0200\u0207\u0003\u0012\t\u0000\u0201\u0207"+
		"\u0003\u0014\n\u0000\u0202\u0203\u0003\u0012\t\u0000\u0203\u0204\u0005"+
		"w\u0000\u0000\u0204\u0205\u0003\u0014\n\u0000\u0205\u0207\u0001\u0000"+
		"\u0000\u0000\u0206\u0200\u0001\u0000\u0000\u0000\u0206\u0201\u0001\u0000"+
		"\u0000\u0000\u0206\u0202\u0001\u0000\u0000\u0000\u0207\u0011\u0001\u0000"+
		"\u0000\u0000\u0208\u0209\u0007\u0000\u0000\u0000\u0209\u0013\u0001\u0000"+
		"\u0000\u0000\u020a\u020b\u0006\n\uffff\uffff\u0000\u020b\u020d\u0003\u0016"+
		"\u000b\u0000\u020c\u020e\u0005\u0080\u0000\u0000\u020d\u020c\u0001\u0000"+
		"\u0000\u0000\u020d\u020e\u0001\u0000\u0000\u0000\u020e\u0217\u0001\u0000"+
		"\u0000\u0000\u020f\u0210\n\u0001\u0000\u0000\u0210\u0211\u0005w\u0000"+
		"\u0000\u0211\u0213\u0003\u0016\u000b\u0000\u0212\u0214\u0005\u0080\u0000"+
		"\u0000\u0213\u0212\u0001\u0000\u0000\u0000\u0213\u0214\u0001\u0000\u0000"+
		"\u0000\u0214\u0216\u0001\u0000\u0000\u0000\u0215\u020f\u0001\u0000\u0000"+
		"\u0000\u0216\u0219\u0001\u0000\u0000\u0000\u0217\u0215\u0001\u0000\u0000"+
		"\u0000\u0217\u0218\u0001\u0000\u0000\u0000\u0218\u0015\u0001\u0000\u0000"+
		"\u0000\u0219\u0217\u0001\u0000\u0000\u0000\u021a\u021d\u0003\u0018\f\u0000"+
		"\u021b\u021d\u0003\u001a\r\u0000\u021c\u021a\u0001\u0000\u0000\u0000\u021c"+
		"\u021b\u0001\u0000\u0000\u0000\u021d\u0017\u0001\u0000\u0000\u0000\u021e"+
		"\u0223\u0005\u0081\u0000\u0000\u021f\u0220\u0005`\u0000\u0000\u0220\u0223"+
		"\u0005\u0081\u0000\u0000\u0221\u0223\u0005C\u0000\u0000\u0222\u021e\u0001"+
		"\u0000\u0000\u0000\u0222\u021f\u0001\u0000\u0000\u0000\u0222\u0221\u0001"+
		"\u0000\u0000\u0000\u0223\u0019\u0001\u0000\u0000\u0000\u0224\u0225\u0005"+
		"\u0081\u0000\u0000\u0225\u022a\u0003\u0124\u0092\u0000\u0226\u0227\u0005"+
		"`\u0000\u0000\u0227\u0228\u0005\u0081\u0000\u0000\u0228\u022a\u0003\u0124"+
		"\u0092\u0000\u0229\u0224\u0001\u0000\u0000\u0000\u0229\u0226\u0001\u0000"+
		"\u0000\u0000\u022a\u001b\u0001\u0000\u0000\u0000\u022b\u022c\u0005T\u0000"+
		"\u0000\u022c\u022d\u0003\u011a\u008d\u0000\u022d\u022f\u0005U\u0000\u0000"+
		"\u022e\u0230\u0005-\u0000\u0000\u022f\u022e\u0001\u0000\u0000\u0000\u022f"+
		"\u0230\u0001\u0000\u0000\u0000\u0230\u0232\u0001\u0000\u0000\u0000\u0231"+
		"\u0233\u0003\u0198\u00cc\u0000\u0232\u0231\u0001\u0000\u0000\u0000\u0232"+
		"\u0233\u0001\u0000\u0000\u0000\u0233\u0235\u0001\u0000\u0000\u0000\u0234"+
		"\u0236\u0003\u00e0p\u0000\u0235\u0234\u0001\u0000\u0000\u0000\u0235\u0236"+
		"\u0001\u0000\u0000\u0000\u0236\u0238\u0001\u0000\u0000\u0000\u0237\u0239"+
		"\u0003\u0102\u0081\u0000\u0238\u0237\u0001\u0000\u0000\u0000\u0238\u0239"+
		"\u0001\u0000\u0000\u0000\u0239\u001d\u0001\u0000\u0000\u0000\u023a\u023b"+
		"\u0006\u000f\uffff\uffff\u0000\u023b\u027c\u0003\u0002\u0001\u0000\u023c"+
		"\u023d\u0003\u00a8T\u0000\u023d\u023f\u0005T\u0000\u0000\u023e\u0240\u0003"+
		"$\u0012\u0000\u023f\u023e\u0001\u0000\u0000\u0000\u023f\u0240\u0001\u0000"+
		"\u0000\u0000\u0240\u0241\u0001\u0000\u0000\u0000\u0241\u0242\u0005U\u0000"+
		"\u0000\u0242\u027c\u0001\u0000\u0000\u0000\u0243\u0244\u0003\u0186\u00c3"+
		"\u0000\u0244\u0246\u0005T\u0000\u0000\u0245\u0247\u0003$\u0012\u0000\u0246"+
		"\u0245\u0001\u0000\u0000\u0000\u0246\u0247\u0001\u0000\u0000\u0000\u0247"+
		"\u0248\u0001\u0000\u0000\u0000\u0248\u0249\u0005U\u0000\u0000\u0249\u027c"+
		"\u0001\u0000\u0000\u0000\u024a\u024c\u0003\u00a8T\u0000\u024b\u024d\u0003"+
		"\u012c\u0096\u0000\u024c\u024b\u0001\u0000\u0000\u0000\u024c\u024d\u0001"+
		"\u0000\u0000\u0000\u024d\u027c\u0001\u0000\u0000\u0000\u024e\u024f\u0003"+
		"\u0186\u00c3\u0000\u024f\u0250\u0003\u012c\u0096\u0000\u0250\u027c\u0001"+
		"\u0000\u0000\u0000\u0251\u0252\u0005\u001d\u0000\u0000\u0252\u0253\u0005"+
		"e\u0000\u0000\u0253\u0254\u0003\u010e\u0087\u0000\u0254\u0255\u0005f\u0000"+
		"\u0000\u0255\u0256\u0005T\u0000\u0000\u0256\u0257\u0003f3\u0000\u0257"+
		"\u0258\u0005U\u0000\u0000\u0258\u027c\u0001\u0000\u0000\u0000\u0259\u025a"+
		"\u0005?\u0000\u0000\u025a\u025b\u0005e\u0000\u0000\u025b\u025c\u0003\u010e"+
		"\u0087\u0000\u025c\u025d\u0005f\u0000\u0000\u025d\u025e\u0005T\u0000\u0000"+
		"\u025e\u025f\u0003f3\u0000\u025f\u0260\u0005U\u0000\u0000\u0260\u027c"+
		"\u0001\u0000\u0000\u0000\u0261\u0262\u00058\u0000\u0000\u0262\u0263\u0005"+
		"e\u0000\u0000\u0263\u0264\u0003\u010e\u0087\u0000\u0264\u0265\u0005f\u0000"+
		"\u0000\u0265\u0266\u0005T\u0000\u0000\u0266\u0267\u0003f3\u0000\u0267"+
		"\u0268\u0005U\u0000\u0000\u0268\u027c\u0001\u0000\u0000\u0000\u0269\u026a"+
		"\u0005\u0016\u0000\u0000\u026a\u026b\u0005e\u0000\u0000\u026b\u026c\u0003"+
		"\u010e\u0087\u0000\u026c\u026d\u0005f\u0000\u0000\u026d\u026e\u0005T\u0000"+
		"\u0000\u026e\u026f\u0003f3\u0000\u026f\u0270\u0005U\u0000\u0000\u0270"+
		"\u027c\u0001\u0000\u0000\u0000\u0271\u0272\u0003\"\u0011\u0000\u0272\u0273"+
		"\u0005T\u0000\u0000\u0273\u0274\u0003f3\u0000\u0274\u0275\u0005U\u0000"+
		"\u0000\u0275\u027c\u0001\u0000\u0000\u0000\u0276\u0277\u0003\"\u0011\u0000"+
		"\u0277\u0278\u0005T\u0000\u0000\u0278\u0279\u0003\u010e\u0087\u0000\u0279"+
		"\u027a\u0005U\u0000\u0000\u027a\u027c\u0001\u0000\u0000\u0000\u027b\u023a"+
		"\u0001\u0000\u0000\u0000\u027b\u023c\u0001\u0000\u0000\u0000\u027b\u0243"+
		"\u0001\u0000\u0000\u0000\u027b\u024a\u0001\u0000\u0000\u0000\u027b\u024e"+
		"\u0001\u0000\u0000\u0000\u027b\u0251\u0001\u0000\u0000\u0000\u027b\u0259"+
		"\u0001\u0000\u0000\u0000\u027b\u0261\u0001\u0000\u0000\u0000\u027b\u0269"+
		"\u0001\u0000\u0000\u0000\u027b\u0271\u0001\u0000\u0000\u0000\u027b\u0276"+
		"\u0001\u0000\u0000\u0000\u027c\u02a5\u0001\u0000\u0000\u0000\u027d\u027e"+
		"\n\u0013\u0000\u0000\u027e\u027f\u0005V\u0000\u0000\u027f\u0280\u0003"+
		"f3\u0000\u0280\u0281\u0005W\u0000\u0000\u0281\u02a4\u0001\u0000\u0000"+
		"\u0000\u0282\u0283\n\u0012\u0000\u0000\u0283\u0284\u0005V\u0000\u0000"+
		"\u0284\u0285\u0003\u012c\u0096\u0000\u0285\u0286\u0005W\u0000\u0000\u0286"+
		"\u02a4\u0001\u0000\u0000\u0000\u0287\u0288\n\u0011\u0000\u0000\u0288\u028a"+
		"\u0005T\u0000\u0000\u0289\u028b\u0003$\u0012\u0000\u028a\u0289\u0001\u0000"+
		"\u0000\u0000\u028a\u028b\u0001\u0000\u0000\u0000\u028b\u028c\u0001\u0000"+
		"\u0000\u0000\u028c\u02a4\u0005U\u0000\u0000\u028d\u028e\n\f\u0000\u0000"+
		"\u028e\u0290\u0005~\u0000\u0000\u028f\u0291\u0005B\u0000\u0000\u0290\u028f"+
		"\u0001\u0000\u0000\u0000\u0290\u0291\u0001\u0000\u0000\u0000\u0291\u0292"+
		"\u0001\u0000\u0000\u0000\u0292\u02a4\u0003\u0004\u0002\u0000\u0293\u0294"+
		"\n\u000b\u0000\u0000\u0294\u0296\u0005y\u0000\u0000\u0295\u0297\u0005"+
		"B\u0000\u0000\u0296\u0295\u0001\u0000\u0000\u0000\u0296\u0297\u0001\u0000"+
		"\u0000\u0000\u0297\u0298\u0001\u0000\u0000\u0000\u0298\u02a4\u0003\u0004"+
		"\u0002\u0000\u0299\u029a\n\n\u0000\u0000\u029a\u029b\u0005~\u0000\u0000"+
		"\u029b\u02a4\u0003&\u0013\u0000\u029c\u029d\n\t\u0000\u0000\u029d\u029e"+
		"\u0005y\u0000\u0000\u029e\u02a4\u0003&\u0013\u0000\u029f\u02a0\n\b\u0000"+
		"\u0000\u02a0\u02a4\u0005u\u0000\u0000\u02a1\u02a2\n\u0007\u0000\u0000"+
		"\u02a2\u02a4\u0005v\u0000\u0000\u02a3\u027d\u0001\u0000\u0000\u0000\u02a3"+
		"\u0282\u0001\u0000\u0000\u0000\u02a3\u0287\u0001\u0000\u0000\u0000\u02a3"+
		"\u028d\u0001\u0000\u0000\u0000\u02a3\u0293\u0001\u0000\u0000\u0000\u02a3"+
		"\u0299\u0001\u0000\u0000\u0000\u02a3\u029c\u0001\u0000\u0000\u0000\u02a3"+
		"\u029f\u0001\u0000\u0000\u0000\u02a3\u02a1\u0001\u0000\u0000\u0000\u02a4"+
		"\u02a7\u0001\u0000\u0000\u0000\u02a5\u02a3\u0001\u0000\u0000\u0000\u02a5"+
		"\u02a6\u0001\u0000\u0000\u0000\u02a6\u001f\u0001\u0000\u0000\u0000\u02a7"+
		"\u02a5\u0001\u0000\u0000\u0000\u02a8\u02a9\u0005I\u0000\u0000\u02a9!\u0001"+
		"\u0000\u0000\u0000\u02aa\u02ab\u0005I\u0000\u0000\u02ab#\u0001\u0000\u0000"+
		"\u0000\u02ac\u02ad\u0003\u012a\u0095\u0000\u02ad%\u0001\u0000\u0000\u0000"+
		"\u02ae\u02b0\u0003\n\u0005\u0000\u02af\u02ae\u0001\u0000\u0000\u0000\u02af"+
		"\u02b0\u0001\u0000\u0000\u0000\u02b0\u02b1\u0001\u0000\u0000\u0000\u02b1"+
		"\u02b2\u0003\u00aaU\u0000\u02b2\u02b3\u0005|\u0000\u0000\u02b3\u02b4\u0005"+
		"b\u0000\u0000\u02b4\u02b5\u0003\u00aaU\u0000\u02b5\u02c5\u0001\u0000\u0000"+
		"\u0000\u02b6\u02b7\u0003\n\u0005\u0000\u02b7\u02b8\u0005B\u0000\u0000"+
		"\u02b8\u02b9\u0003\u017c\u00be\u0000\u02b9\u02ba\u0005|\u0000\u0000\u02ba"+
		"\u02bb\u0005b\u0000\u0000\u02bb\u02bc\u0003\u00aaU\u0000\u02bc\u02c5\u0001"+
		"\u0000\u0000\u0000\u02bd\u02bf\u0003\n\u0005\u0000\u02be\u02bd\u0001\u0000"+
		"\u0000\u0000\u02be\u02bf\u0001\u0000\u0000\u0000\u02bf\u02c0\u0001\u0000"+
		"\u0000\u0000\u02c0\u02c1\u0005b\u0000\u0000\u02c1\u02c5\u0003\u00aaU\u0000"+
		"\u02c2\u02c3\u0005b\u0000\u0000\u02c3\u02c5\u0003\u00acV\u0000\u02c4\u02af"+
		"\u0001\u0000\u0000\u0000\u02c4\u02b6\u0001\u0000\u0000\u0000\u02c4\u02be"+
		"\u0001\u0000\u0000\u0000\u02c4\u02c2\u0001\u0000\u0000\u0000\u02c5\'\u0001"+
		"\u0000\u0000\u0000\u02c6\u02e3\u0003\u001e\u000f\u0000\u02c7\u02c8\u0005"+
		"u\u0000\u0000\u02c8\u02e3\u0003<\u001e\u0000\u02c9\u02ca\u0005v\u0000"+
		"\u0000\u02ca\u02e3\u0003<\u001e\u0000\u02cb\u02cc\u0003*\u0015\u0000\u02cc"+
		"\u02cd\u0003<\u001e\u0000\u02cd\u02e3\u0001\u0000\u0000\u0000\u02ce\u02cf"+
		"\u0005<\u0000\u0000\u02cf\u02e3\u0003(\u0014\u0000\u02d0\u02d1\u0005<"+
		"\u0000\u0000\u02d1\u02d2\u0005T\u0000\u0000\u02d2\u02d3\u0003\u010e\u0087"+
		"\u0000\u02d3\u02d4\u0005U\u0000\u0000\u02d4\u02e3\u0001\u0000\u0000\u0000"+
		"\u02d5\u02d6\u0005<\u0000\u0000\u02d6\u02d7\u0005\u0080\u0000\u0000\u02d7"+
		"\u02d8\u0005T\u0000\u0000\u02d8\u02d9\u0005\u0081\u0000\u0000\u02d9\u02e3"+
		"\u0005U\u0000\u0000\u02da\u02db\u0005\t\u0000\u0000\u02db\u02dc\u0005"+
		"T\u0000\u0000\u02dc\u02dd\u0003\u010e\u0087\u0000\u02dd\u02de\u0005U\u0000"+
		"\u0000\u02de\u02e3\u0001\u0000\u0000\u0000\u02df\u02e3\u0003:\u001d\u0000"+
		"\u02e0\u02e3\u0003,\u0016\u0000\u02e1\u02e3\u00038\u001c\u0000\u02e2\u02c6"+
		"\u0001\u0000\u0000\u0000\u02e2\u02c7\u0001\u0000\u0000\u0000\u02e2\u02c9"+
		"\u0001\u0000\u0000\u0000\u02e2\u02cb\u0001\u0000\u0000\u0000\u02e2\u02ce"+
		"\u0001\u0000\u0000\u0000\u02e2\u02d0\u0001\u0000\u0000\u0000\u02e2\u02d5"+
		"\u0001\u0000\u0000\u0000\u02e2\u02da\u0001\u0000\u0000\u0000\u02e2\u02df"+
		"\u0001\u0000\u0000\u0000\u02e2\u02e0\u0001\u0000\u0000\u0000\u02e2\u02e1"+
		"\u0001\u0000\u0000\u0000\u02e3)\u0001\u0000\u0000\u0000\u02e4\u02e5\u0007"+
		"\u0001\u0000\u0000\u02e5+\u0001\u0000\u0000\u0000\u02e6\u02e8\u0005|\u0000"+
		"\u0000\u02e7\u02e6\u0001\u0000\u0000\u0000\u02e7\u02e8\u0001\u0000\u0000"+
		"\u0000\u02e8\u02e9\u0001\u0000\u0000\u0000\u02e9\u02eb\u0005/\u0000\u0000"+
		"\u02ea\u02ec\u0003.\u0017\u0000\u02eb\u02ea\u0001\u0000\u0000\u0000\u02eb"+
		"\u02ec\u0001\u0000\u0000\u0000\u02ec\u02ed\u0001\u0000\u0000\u0000\u02ed"+
		"\u02ef\u00030\u0018\u0000\u02ee\u02f0\u00036\u001b\u0000\u02ef\u02ee\u0001"+
		"\u0000\u0000\u0000\u02ef\u02f0\u0001\u0000\u0000\u0000\u02f0\u02ff\u0001"+
		"\u0000\u0000\u0000\u02f1\u02f3\u0005|\u0000\u0000\u02f2\u02f1\u0001\u0000"+
		"\u0000\u0000\u02f2\u02f3\u0001\u0000\u0000\u0000\u02f3\u02f4\u0001\u0000"+
		"\u0000\u0000\u02f4\u02f6\u0005/\u0000\u0000\u02f5\u02f7\u0003.\u0017\u0000"+
		"\u02f6\u02f5\u0001\u0000\u0000\u0000\u02f6\u02f7\u0001\u0000\u0000\u0000"+
		"\u02f7\u02f8\u0001\u0000\u0000\u0000\u02f8\u02f9\u0005T\u0000\u0000\u02f9"+
		"\u02fa\u0003\u010e\u0087\u0000\u02fa\u02fc\u0005U\u0000\u0000\u02fb\u02fd"+
		"\u00036\u001b\u0000\u02fc\u02fb\u0001\u0000\u0000\u0000\u02fc\u02fd\u0001"+
		"\u0000\u0000\u0000\u02fd\u02ff\u0001\u0000\u0000\u0000\u02fe\u02e7\u0001"+
		"\u0000\u0000\u0000\u02fe\u02f2\u0001\u0000\u0000\u0000\u02ff-\u0001\u0000"+
		"\u0000\u0000\u0300\u0301\u0005T\u0000\u0000\u0301\u0302\u0003$\u0012\u0000"+
		"\u0302\u0303\u0005U\u0000\u0000\u0303/\u0001\u0000\u0000\u0000\u0304\u0306"+
		"\u0003\u00a4R\u0000\u0305\u0307\u00032\u0019\u0000\u0306\u0305\u0001\u0000"+
		"\u0000\u0000\u0306\u0307\u0001\u0000\u0000\u0000\u03071\u0001\u0000\u0000"+
		"\u0000\u0308\u030a\u0003\u0104\u0082\u0000\u0309\u030b\u00032\u0019\u0000"+
		"\u030a\u0309\u0001\u0000\u0000\u0000\u030a\u030b\u0001\u0000\u0000\u0000"+
		"\u030b\u030e\u0001\u0000\u0000\u0000\u030c\u030e\u00034\u001a\u0000\u030d"+
		"\u0308\u0001\u0000\u0000\u0000\u030d\u030c\u0001\u0000\u0000\u0000\u030e"+
		"3\u0001\u0000\u0000\u0000\u030f\u0310\u0006\u001a\uffff\uffff\u0000\u0310"+
		"\u0311\u0005V\u0000\u0000\u0311\u0312\u0003f3\u0000\u0312\u0314\u0005"+
		"W\u0000\u0000\u0313\u0315\u0003\u00e0p\u0000\u0314\u0313\u0001\u0000\u0000"+
		"\u0000\u0314\u0315\u0001\u0000\u0000\u0000\u0315\u031f\u0001\u0000\u0000"+
		"\u0000\u0316\u0317\n\u0001\u0000\u0000\u0317\u0318\u0005V\u0000\u0000"+
		"\u0318\u0319\u0003h4\u0000\u0319\u031b\u0005W\u0000\u0000\u031a\u031c"+
		"\u0003\u00e0p\u0000\u031b\u031a\u0001\u0000\u0000\u0000\u031b\u031c\u0001"+
		"\u0000\u0000\u0000\u031c\u031e\u0001\u0000\u0000\u0000\u031d\u0316\u0001"+
		"\u0000\u0000\u0000\u031e\u0321\u0001\u0000\u0000\u0000\u031f\u031d\u0001"+
		"\u0000\u0000\u0000\u031f\u0320\u0001\u0000\u0000\u0000\u03205\u0001\u0000"+
		"\u0000\u0000\u0321\u031f\u0001\u0000\u0000\u0000\u0322\u0324\u0005T\u0000"+
		"\u0000\u0323\u0325\u0003$\u0012\u0000\u0324\u0323\u0001\u0000\u0000\u0000"+
		"\u0324\u0325\u0001\u0000\u0000\u0000\u0325\u0326\u0001\u0000\u0000\u0000"+
		"\u0326\u0329\u0005U\u0000\u0000\u0327\u0329\u0003\u012c\u0096\u0000\u0328"+
		"\u0322\u0001\u0000\u0000\u0000\u0328\u0327\u0001\u0000\u0000\u0000\u0329"+
		"7\u0001\u0000\u0000\u0000\u032a\u032c\u0005|\u0000\u0000\u032b\u032a\u0001"+
		"\u0000\u0000\u0000\u032b\u032c\u0001\u0000\u0000\u0000\u032c\u032d\u0001"+
		"\u0000\u0000\u0000\u032d\u032e\u0005\u001a\u0000\u0000\u032e\u0337\u0003"+
		"<\u001e\u0000\u032f\u0331\u0005|\u0000\u0000\u0330\u032f\u0001\u0000\u0000"+
		"\u0000\u0330\u0331\u0001\u0000\u0000\u0000\u0331\u0332\u0001\u0000\u0000"+
		"\u0000\u0332\u0333\u0005\u001a\u0000\u0000\u0333\u0334\u0005V\u0000\u0000"+
		"\u0334\u0335\u0005W\u0000\u0000\u0335\u0337\u0003<\u001e\u0000\u0336\u032b"+
		"\u0001\u0000\u0000\u0000\u0336\u0330\u0001\u0000\u0000\u0000\u03379\u0001"+
		"\u0000\u0000\u0000\u0338\u0339\u00050\u0000\u0000\u0339\u033a\u0005T\u0000"+
		"\u0000\u033a\u033b\u0003f3\u0000\u033b\u033c\u0005U\u0000\u0000\u033c"+
		";\u0001\u0000\u0000\u0000\u033d\u0344\u0003(\u0014\u0000\u033e\u033f\u0005"+
		"T\u0000\u0000\u033f\u0340\u0003\u010e\u0087\u0000\u0340\u0341\u0005U\u0000"+
		"\u0000\u0341\u0342\u0003<\u001e\u0000\u0342\u0344\u0001\u0000\u0000\u0000"+
		"\u0343\u033d\u0001\u0000\u0000\u0000\u0343\u033e\u0001\u0000\u0000\u0000"+
		"\u0344=\u0001\u0000\u0000\u0000\u0345\u0346\u0006\u001f\uffff\uffff\u0000"+
		"\u0346\u0347\u0003<\u001e\u0000\u0347\u0350\u0001\u0000\u0000\u0000\u0348"+
		"\u0349\n\u0002\u0000\u0000\u0349\u034a\u0005\u007f\u0000\u0000\u034a\u034f"+
		"\u0003<\u001e\u0000\u034b\u034c\n\u0001\u0000\u0000\u034c\u034d\u0005"+
		"x\u0000\u0000\u034d\u034f\u0003<\u001e\u0000\u034e\u0348\u0001\u0000\u0000"+
		"\u0000\u034e\u034b\u0001\u0000\u0000\u0000\u034f\u0352\u0001\u0000\u0000"+
		"\u0000\u0350\u034e\u0001\u0000\u0000\u0000\u0350\u0351\u0001\u0000\u0000"+
		"\u0000\u0351?\u0001\u0000\u0000\u0000\u0352\u0350\u0001\u0000\u0000\u0000"+
		"\u0353\u0354\u0006 \uffff\uffff\u0000\u0354\u0355\u0003>\u001f\u0000\u0355"+
		"\u0367\u0001\u0000\u0000\u0000\u0356\u0357\n\u0004\u0000\u0000\u0357\u0358"+
		"\u0005\\\u0000\u0000\u0358\u0366\u0003>\u001f\u0000\u0359\u035a\n\u0003"+
		"\u0000\u0000\u035a\u035c\u0005\\\u0000\u0000\u035b\u035d\u0003F#\u0000"+
		"\u035c\u035b\u0001\u0000\u0000\u0000\u035c\u035d\u0001\u0000\u0000\u0000"+
		"\u035d\u035e\u0001\u0000\u0000\u0000\u035e\u0366\u0003>\u001f\u0000\u035f"+
		"\u0360\n\u0002\u0000\u0000\u0360\u0361\u0005]\u0000\u0000\u0361\u0366"+
		"\u0003>\u001f\u0000\u0362\u0363\n\u0001\u0000\u0000\u0363\u0364\u0005"+
		"^\u0000\u0000\u0364\u0366\u0003>\u001f\u0000\u0365\u0356\u0001\u0000\u0000"+
		"\u0000\u0365\u0359\u0001\u0000\u0000\u0000\u0365\u035f\u0001\u0000\u0000"+
		"\u0000\u0365\u0362\u0001\u0000\u0000\u0000\u0366\u0369\u0001\u0000\u0000"+
		"\u0000\u0367\u0365\u0001\u0000\u0000\u0000\u0367\u0368\u0001\u0000\u0000"+
		"\u0000\u0368A\u0001\u0000\u0000\u0000\u0369\u0367\u0001\u0000\u0000\u0000"+
		"\u036a\u036b\u0006!\uffff\uffff\u0000\u036b\u036c\u0003@ \u0000\u036c"+
		"\u0375\u0001\u0000\u0000\u0000\u036d\u036e\n\u0002\u0000\u0000\u036e\u036f"+
		"\u0005Z\u0000\u0000\u036f\u0374\u0003@ \u0000\u0370\u0371\n\u0001\u0000"+
		"\u0000\u0371\u0372\u0005[\u0000\u0000\u0372\u0374\u0003@ \u0000\u0373"+
		"\u036d\u0001\u0000\u0000\u0000\u0373\u0370\u0001\u0000\u0000\u0000\u0374"+
		"\u0377\u0001\u0000\u0000\u0000\u0375\u0373\u0001\u0000\u0000\u0000\u0375"+
		"\u0376\u0001\u0000\u0000\u0000\u0376C\u0001\u0000\u0000\u0000\u0377\u0375"+
		"\u0001\u0000\u0000\u0000\u0378\u0379\u0006\"\uffff\uffff\u0000\u0379\u037a"+
		"\u0003B!\u0000\u037a\u0384\u0001\u0000\u0000\u0000\u037b\u037c\n\u0002"+
		"\u0000\u0000\u037c\u037d\u0003L&\u0000\u037d\u037e\u0003B!\u0000\u037e"+
		"\u0383\u0001\u0000\u0000\u0000\u037f\u0380\n\u0001\u0000\u0000\u0380\u0381"+
		"\u0005e\u0000\u0000\u0381\u0383\u0003B!\u0000\u0382\u037b\u0001\u0000"+
		"\u0000\u0000\u0382\u037f\u0001\u0000\u0000\u0000\u0383\u0386\u0001\u0000"+
		"\u0000\u0000\u0384\u0382\u0001\u0000\u0000\u0000\u0384\u0385\u0001\u0000"+
		"\u0000\u0000\u0385E\u0001\u0000\u0000\u0000\u0386\u0384\u0001\u0000\u0000"+
		"\u0000\u0387\u0388\u0005S\u0000\u0000\u0388G\u0001\u0000\u0000\u0000\u0389"+
		"\u038a\u0006$\uffff\uffff\u0000\u038a\u038b\u0003J%\u0000\u038b\u0390"+
		"\u0001\u0000\u0000\u0000\u038c\u038d\n\u0001\u0000\u0000\u038d\u038f\u0003"+
		"J%\u0000\u038e\u038c\u0001\u0000\u0000\u0000\u038f\u0392\u0001\u0000\u0000"+
		"\u0000\u0390\u038e\u0001\u0000\u0000\u0000\u0390\u0391\u0001\u0000\u0000"+
		"\u0000\u0391I\u0001\u0000\u0000\u0000\u0392\u0390\u0001\u0000\u0000\u0000"+
		"\u0393\u0394\u0005\\\u0000\u0000\u0394\u0399\u0005S\u0000\u0000\u0395"+
		"\u0396\u0005\\\u0000\u0000\u0396\u0397\u0005\u0014\u0000\u0000\u0397\u0399"+
		"\u0005S\u0000\u0000\u0398\u0393\u0001\u0000\u0000\u0000\u0398\u0395\u0001"+
		"\u0000\u0000\u0000\u0399K\u0001\u0000\u0000\u0000\u039a\u039d\u0003\u01a4"+
		"\u00d2\u0000\u039b\u039d\u0003\u01a0\u00d0\u0000\u039c\u039a\u0001\u0000"+
		"\u0000\u0000\u039c\u039b\u0001\u0000\u0000\u0000\u039dM\u0001\u0000\u0000"+
		"\u0000\u039e\u039f\u0006\'\uffff\uffff\u0000\u039f\u03a0\u0003D\"\u0000"+
		"\u03a0\u03ac\u0001\u0000\u0000\u0000\u03a1\u03a2\n\u0003\u0000\u0000\u03a2"+
		"\u03a3\u0005f\u0000\u0000\u03a3\u03ab\u0003D\"\u0000\u03a4\u03a5\n\u0002"+
		"\u0000\u0000\u03a5\u03a6\u0005q\u0000\u0000\u03a6\u03ab\u0003D\"\u0000"+
		"\u03a7\u03a8\n\u0001\u0000\u0000\u03a8\u03a9\u0005r\u0000\u0000\u03a9"+
		"\u03ab\u0003D\"\u0000\u03aa\u03a1\u0001\u0000\u0000\u0000\u03aa\u03a4"+
		"\u0001\u0000\u0000\u0000\u03aa\u03a7\u0001\u0000\u0000\u0000\u03ab\u03ae"+
		"\u0001\u0000\u0000\u0000\u03ac\u03aa\u0001\u0000\u0000\u0000\u03ac\u03ad"+
		"\u0001\u0000\u0000\u0000\u03adO\u0001\u0000\u0000\u0000\u03ae\u03ac\u0001"+
		"\u0000\u0000\u0000\u03af\u03b0\u0006(\uffff\uffff\u0000\u03b0\u03b1\u0003"+
		"N\'\u0000\u03b1\u03ba\u0001\u0000\u0000\u0000\u03b2\u03b3\n\u0002\u0000"+
		"\u0000\u03b3\u03b4\u0005o\u0000\u0000\u03b4\u03b9\u0003N\'\u0000\u03b5"+
		"\u03b6\n\u0001\u0000\u0000\u03b6\u03b7\u0005p\u0000\u0000\u03b7\u03b9"+
		"\u0003N\'\u0000\u03b8\u03b2\u0001\u0000\u0000\u0000\u03b8\u03b5\u0001"+
		"\u0000\u0000\u0000\u03b9\u03bc\u0001\u0000\u0000\u0000\u03ba\u03b8\u0001"+
		"\u0000\u0000\u0000\u03ba\u03bb\u0001\u0000\u0000\u0000\u03bbQ\u0001\u0000"+
		"\u0000\u0000\u03bc\u03ba\u0001\u0000\u0000\u0000\u03bd\u03be\u0006)\uffff"+
		"\uffff\u0000\u03be\u03bf\u0003P(\u0000\u03bf\u03c5\u0001\u0000\u0000\u0000"+
		"\u03c0\u03c1\n\u0001\u0000\u0000\u03c1\u03c2\u0005`\u0000\u0000\u03c2"+
		"\u03c4\u0003P(\u0000\u03c3\u03c0\u0001\u0000\u0000\u0000\u03c4\u03c7\u0001"+
		"\u0000\u0000\u0000\u03c5\u03c3\u0001\u0000\u0000\u0000\u03c5\u03c6\u0001"+
		"\u0000\u0000\u0000\u03c6S\u0001\u0000\u0000\u0000\u03c7\u03c5\u0001\u0000"+
		"\u0000\u0000\u03c8\u03c9\u0006*\uffff\uffff\u0000\u03c9\u03ca\u0003R)"+
		"\u0000\u03ca\u03d0\u0001\u0000\u0000\u0000\u03cb\u03cc\n\u0001\u0000\u0000"+
		"\u03cc\u03cd\u0005_\u0000\u0000\u03cd\u03cf\u0003R)\u0000\u03ce\u03cb"+
		"\u0001\u0000\u0000\u0000\u03cf\u03d2\u0001\u0000\u0000\u0000\u03d0\u03ce"+
		"\u0001\u0000\u0000\u0000\u03d0\u03d1\u0001\u0000\u0000\u0000\u03d1U\u0001"+
		"\u0000\u0000\u0000\u03d2\u03d0\u0001\u0000\u0000\u0000\u03d3\u03d4\u0006"+
		"+\uffff\uffff\u0000\u03d4\u03d5\u0003T*\u0000\u03d5\u03db\u0001\u0000"+
		"\u0000\u0000\u03d6\u03d7\n\u0001\u0000\u0000\u03d7\u03d8\u0005a\u0000"+
		"\u0000\u03d8\u03da\u0003T*\u0000\u03d9\u03d6\u0001\u0000\u0000\u0000\u03da"+
		"\u03dd\u0001\u0000\u0000\u0000\u03db\u03d9\u0001\u0000\u0000\u0000\u03db"+
		"\u03dc\u0001\u0000\u0000\u0000\u03dcW\u0001\u0000\u0000\u0000\u03dd\u03db"+
		"\u0001\u0000\u0000\u0000\u03de\u03df\u0006,\uffff\uffff\u0000\u03df\u03e0"+
		"\u0003V+\u0000\u03e0\u03ea\u0001\u0000\u0000\u0000\u03e1\u03e2\n\u0002"+
		"\u0000\u0000\u03e2\u03e3\u0003Z-\u0000\u03e3\u03e4\u0003V+\u0000\u03e4"+
		"\u03e9\u0001\u0000\u0000\u0000\u03e5\u03e6\n\u0001\u0000\u0000\u03e6\u03e7"+
		"\u0005\u0003\u0000\u0000\u03e7\u03e9\u0003V+\u0000\u03e8\u03e1\u0001\u0000"+
		"\u0000\u0000\u03e8\u03e5\u0001\u0000\u0000\u0000\u03e9\u03ec\u0001\u0000"+
		"\u0000\u0000\u03ea\u03e8\u0001\u0000\u0000\u0000\u03ea\u03eb\u0001\u0000"+
		"\u0000\u0000\u03ebY\u0001\u0000\u0000\u0000\u03ec\u03ea\u0001\u0000\u0000"+
		"\u0000\u03ed\u03ee\u0005\u0004\u0000\u0000\u03ee[\u0001\u0000\u0000\u0000"+
		"\u03ef\u03f0\u0006.\uffff\uffff\u0000\u03f0\u03f1\u0003X,\u0000\u03f1"+
		"\u03fb\u0001\u0000\u0000\u0000\u03f2\u03f3\n\u0002\u0000\u0000\u03f3\u03f4"+
		"\u0003^/\u0000\u03f4\u03f5\u0003X,\u0000\u03f5\u03fa\u0001\u0000\u0000"+
		"\u0000\u03f6\u03f7\n\u0001\u0000\u0000\u03f7\u03f8\u0005\u0005\u0000\u0000"+
		"\u03f8\u03fa\u0003X,\u0000\u03f9\u03f2\u0001\u0000\u0000\u0000\u03f9\u03f6"+
		"\u0001\u0000\u0000\u0000\u03fa\u03fd\u0001\u0000\u0000\u0000\u03fb\u03f9"+
		"\u0001\u0000\u0000\u0000\u03fb\u03fc\u0001\u0000\u0000\u0000\u03fc]\u0001"+
		"\u0000\u0000\u0000\u03fd\u03fb\u0001\u0000\u0000\u0000\u03fe\u03ff\u0005"+
		"\u0006\u0000\u0000\u03ff_\u0001\u0000\u0000\u0000\u0400\u0408\u0003\\"+
		".\u0000\u0401\u0402\u0003\\.\u0000\u0402\u0403\u0005z\u0000\u0000\u0403"+
		"\u0404\u0003f3\u0000\u0404\u0405\u0005{\u0000\u0000\u0405\u0406\u0003"+
		"b1\u0000\u0406\u0408\u0001\u0000\u0000\u0000\u0407\u0400\u0001\u0000\u0000"+
		"\u0000\u0407\u0401\u0001\u0000\u0000\u0000\u0408a\u0001\u0000\u0000\u0000"+
		"\u0409\u0410\u0003`0\u0000\u040a\u040b\u0003\\.\u0000\u040b\u040c\u0003"+
		"d2\u0000\u040c\u040d\u0003\u0128\u0094\u0000\u040d\u0410\u0001\u0000\u0000"+
		"\u0000\u040e\u0410\u0003\u0196\u00cb\u0000\u040f\u0409\u0001\u0000\u0000"+
		"\u0000\u040f\u040a\u0001\u0000\u0000\u0000\u040f\u040e\u0001\u0000\u0000"+
		"\u0000\u0410c\u0001\u0000\u0000\u0000\u0411\u041d\u0005d\u0000\u0000\u0412"+
		"\u041d\u0005i\u0000\u0000\u0413\u041d\u0005j\u0000\u0000\u0414\u041d\u0005"+
		"k\u0000\u0000\u0415\u041d\u0005g\u0000\u0000\u0416\u041d\u0005h\u0000"+
		"\u0000\u0417\u041d\u0003\u01a6\u00d3\u0000\u0418\u041d\u0003\u01a2\u00d1"+
		"\u0000\u0419\u041d\u0005m\u0000\u0000\u041a\u041d\u0005l\u0000\u0000\u041b"+
		"\u041d\u0005n\u0000\u0000\u041c\u0411\u0001\u0000\u0000\u0000\u041c\u0412"+
		"\u0001\u0000\u0000\u0000\u041c\u0413\u0001\u0000\u0000\u0000\u041c\u0414"+
		"\u0001\u0000\u0000\u0000\u041c\u0415\u0001\u0000\u0000\u0000\u041c\u0416"+
		"\u0001\u0000\u0000\u0000\u041c\u0417\u0001\u0000\u0000\u0000\u041c\u0418"+
		"\u0001\u0000\u0000\u0000\u041c\u0419\u0001\u0000\u0000\u0000\u041c\u041a"+
		"\u0001\u0000\u0000\u0000\u041c\u041b\u0001\u0000\u0000\u0000\u041de\u0001"+
		"\u0000\u0000\u0000\u041e\u041f\u00063\uffff\uffff\u0000\u041f\u0420\u0003"+
		"b1\u0000\u0420\u0426\u0001\u0000\u0000\u0000\u0421\u0422\n\u0001\u0000"+
		"\u0000\u0422\u0423\u0005w\u0000\u0000\u0423\u0425\u0003b1\u0000\u0424"+
		"\u0421\u0001\u0000\u0000\u0000\u0425\u0428\u0001\u0000\u0000\u0000\u0426"+
		"\u0424\u0001\u0000\u0000\u0000\u0426\u0427\u0001\u0000\u0000\u0000\u0427"+
		"g\u0001\u0000\u0000\u0000\u0428\u0426\u0001\u0000\u0000\u0000\u0429\u042a"+
		"\u0003`0\u0000\u042ai\u0001\u0000\u0000\u0000\u042b\u0447\u0003l6\u0000"+
		"\u042c\u042e\u0003\u00e0p\u0000\u042d\u042c\u0001\u0000\u0000\u0000\u042d"+
		"\u042e\u0001\u0000\u0000\u0000\u042e\u042f\u0001\u0000\u0000\u0000\u042f"+
		"\u0447\u0003n7\u0000\u0430\u0432\u0003\u00e0p\u0000\u0431\u0430\u0001"+
		"\u0000\u0000\u0000\u0431\u0432\u0001\u0000\u0000\u0000\u0432\u0433\u0001"+
		"\u0000\u0000\u0000\u0433\u0447\u0003p8\u0000\u0434\u0436\u0003\u00e0p"+
		"\u0000\u0435\u0434\u0001\u0000\u0000\u0000\u0435\u0436\u0001\u0000\u0000"+
		"\u0000\u0436\u0437\u0001\u0000\u0000\u0000\u0437\u0447\u0003t:\u0000\u0438"+
		"\u043a\u0003\u00e0p\u0000\u0439\u0438\u0001\u0000\u0000\u0000\u0439\u043a"+
		"\u0001\u0000\u0000\u0000\u043a\u043b\u0001\u0000\u0000\u0000\u043b\u0447"+
		"\u0003x<\u0000\u043c\u043e\u0003\u00e0p\u0000\u043d\u043c\u0001\u0000"+
		"\u0000\u0000\u043d\u043e\u0001\u0000\u0000\u0000\u043e\u043f\u0001\u0000"+
		"\u0000\u0000\u043f\u0447\u0003\u0080@\u0000\u0440\u0447\u0003\u0082A\u0000"+
		"\u0441\u0443\u0003\u00e0p\u0000\u0442\u0441\u0001\u0000\u0000\u0000\u0442"+
		"\u0443\u0001\u0000\u0000\u0000\u0443\u0444\u0001\u0000\u0000\u0000\u0444"+
		"\u0447\u0003\u018c\u00c6\u0000\u0445\u0447\u0005\u0007\u0000\u0000\u0446"+
		"\u042b\u0001\u0000\u0000\u0000\u0446\u042d\u0001\u0000\u0000\u0000\u0446"+
		"\u0431\u0001\u0000\u0000\u0000\u0446\u0435\u0001\u0000\u0000\u0000\u0446"+
		"\u0439\u0001\u0000\u0000\u0000\u0446\u043d\u0001\u0000\u0000\u0000\u0446"+
		"\u0440\u0001\u0000\u0000\u0000\u0446\u0442\u0001\u0000\u0000\u0000\u0446"+
		"\u0445\u0001\u0000\u0000\u0000\u0447k\u0001\u0000\u0000\u0000\u0448\u044a"+
		"\u0003\u00e0p\u0000\u0449\u0448\u0001\u0000\u0000\u0000\u0449\u044a\u0001"+
		"\u0000\u0000\u0000\u044a\u044b\u0001\u0000\u0000\u0000\u044b\u044c\u0005"+
		"\u0081\u0000\u0000\u044c\u044d\u0005{\u0000\u0000\u044d\u045d\u0003j5"+
		"\u0000\u044e\u0450\u0003\u00e0p\u0000\u044f\u044e\u0001\u0000\u0000\u0000"+
		"\u044f\u0450\u0001\u0000\u0000\u0000\u0450\u0451\u0001\u0000\u0000\u0000"+
		"\u0451\u0452\u0005\u000e\u0000\u0000\u0452\u0453\u0003h4\u0000\u0453\u0454"+
		"\u0005{\u0000\u0000\u0454\u0455\u0003j5\u0000\u0455\u045d\u0001\u0000"+
		"\u0000\u0000\u0456\u0458\u0003\u00e0p\u0000\u0457\u0456\u0001\u0000\u0000"+
		"\u0000\u0457\u0458\u0001\u0000\u0000\u0000\u0458\u0459\u0001\u0000\u0000"+
		"\u0000\u0459\u045a\u0005\u0019\u0000\u0000\u045a\u045b\u0005{\u0000\u0000"+
		"\u045b\u045d\u0003j5\u0000\u045c\u0449\u0001\u0000\u0000\u0000\u045c\u044f"+
		"\u0001\u0000\u0000\u0000\u045c\u0457\u0001\u0000\u0000\u0000\u045dm\u0001"+
		"\u0000\u0000\u0000\u045e\u0460\u0003f3\u0000\u045f\u045e\u0001\u0000\u0000"+
		"\u0000\u045f\u0460\u0001\u0000\u0000\u0000\u0460\u0461\u0001\u0000\u0000"+
		"\u0000\u0461\u0462\u0005}\u0000\u0000\u0462o\u0001\u0000\u0000\u0000\u0463"+
		"\u0465\u0005X\u0000\u0000\u0464\u0466\u0003r9\u0000\u0465\u0464\u0001"+
		"\u0000\u0000\u0000\u0465\u0466\u0001\u0000\u0000\u0000\u0466\u0467\u0001"+
		"\u0000\u0000\u0000\u0467\u046a\u0005Y\u0000\u0000\u0468\u046a\u0005\u0007"+
		"\u0000\u0000\u0469\u0463\u0001\u0000\u0000\u0000\u0469\u0468\u0001\u0000"+
		"\u0000\u0000\u046aq\u0001\u0000\u0000\u0000\u046b\u046c\u00069\uffff\uffff"+
		"\u0000\u046c\u046d\u0003j5\u0000\u046d\u0472\u0001\u0000\u0000\u0000\u046e"+
		"\u046f\n\u0001\u0000\u0000\u046f\u0471\u0003j5\u0000\u0470\u046e\u0001"+
		"\u0000\u0000\u0000\u0471\u0474\u0001\u0000\u0000\u0000\u0472\u0470\u0001"+
		"\u0000\u0000\u0000\u0472\u0473\u0001\u0000\u0000\u0000\u0473s\u0001\u0000"+
		"\u0000\u0000\u0474\u0472\u0001\u0000\u0000\u0000\u0475\u0476\u0005)\u0000"+
		"\u0000\u0476\u0477\u0005T\u0000\u0000\u0477\u0478\u0003v;\u0000\u0478"+
		"\u0479\u0005U\u0000\u0000\u0479\u047a\u0003j5\u0000\u047a\u048a\u0001"+
		"\u0000\u0000\u0000\u047b\u047c\u0005)\u0000\u0000\u047c\u047d\u0005T\u0000"+
		"\u0000\u047d\u047e\u0003v;\u0000\u047e\u047f\u0005U\u0000\u0000\u047f"+
		"\u0480\u0003j5\u0000\u0480\u0481\u0005\u001e\u0000\u0000\u0481\u0482\u0003"+
		"j5\u0000\u0482\u048a\u0001\u0000\u0000\u0000\u0483\u0484\u0005A\u0000"+
		"\u0000\u0484\u0485\u0005T\u0000\u0000\u0485\u0486\u0003v;\u0000\u0486"+
		"\u0487\u0005U\u0000\u0000\u0487\u0488\u0003j5\u0000\u0488\u048a\u0001"+
		"\u0000\u0000\u0000\u0489\u0475\u0001\u0000\u0000\u0000\u0489\u047b\u0001"+
		"\u0000\u0000\u0000\u0489\u0483\u0001\u0000\u0000\u0000\u048au\u0001\u0000"+
		"\u0000\u0000\u048b\u049c\u0003f3\u0000\u048c\u048e\u0003\u00e0p\u0000"+
		"\u048d\u048c\u0001\u0000\u0000\u0000\u048d\u048e\u0001\u0000\u0000\u0000"+
		"\u048e\u048f\u0001\u0000\u0000\u0000\u048f\u0490\u0003\u0096K\u0000\u0490"+
		"\u0491\u0003\u00fa}\u0000\u0491\u0492\u0005d\u0000\u0000\u0492\u0493\u0003"+
		"\u0128\u0094\u0000\u0493\u049c\u0001\u0000\u0000\u0000\u0494\u0496\u0003"+
		"\u00e0p\u0000\u0495\u0494\u0001\u0000\u0000\u0000\u0495\u0496\u0001\u0000"+
		"\u0000\u0000\u0496\u0497\u0001\u0000\u0000\u0000\u0497\u0498\u0003\u0096"+
		"K\u0000\u0498\u0499\u0003\u00fa}\u0000\u0499\u049a\u0003\u012c\u0096\u0000"+
		"\u049a\u049c\u0001\u0000\u0000\u0000\u049b\u048b\u0001\u0000\u0000\u0000"+
		"\u049b\u048d\u0001\u0000\u0000\u0000\u049b\u0495\u0001\u0000\u0000\u0000"+
		"\u049cw\u0001\u0000\u0000\u0000\u049d\u049e\u0005R\u0000\u0000\u049e\u049f"+
		"\u0005T\u0000\u0000\u049f\u04a0\u0003v;\u0000\u04a0\u04a1\u0005U\u0000"+
		"\u0000\u04a1\u04a2\u0003j5\u0000\u04a2\u04c1\u0001\u0000\u0000\u0000\u04a3"+
		"\u04a4\u0005\u001b\u0000\u0000\u04a4\u04a5\u0003j5\u0000\u04a5\u04a6\u0005"+
		"R\u0000\u0000\u04a6\u04a7\u0005T\u0000\u0000\u04a7\u04a8\u0003f3\u0000"+
		"\u04a8\u04a9\u0005U\u0000\u0000\u04a9\u04aa\u0005}\u0000\u0000\u04aa\u04c1"+
		"\u0001\u0000\u0000\u0000\u04ab\u04ac\u0005&\u0000\u0000\u04ac\u04ad\u0005"+
		"T\u0000\u0000\u04ad\u04af\u0003z=\u0000\u04ae\u04b0\u0003v;\u0000\u04af"+
		"\u04ae\u0001\u0000\u0000\u0000\u04af\u04b0\u0001\u0000\u0000\u0000\u04b0"+
		"\u04b1\u0001\u0000\u0000\u0000\u04b1\u04b3\u0005}\u0000\u0000\u04b2\u04b4"+
		"\u0003f3\u0000\u04b3\u04b2\u0001\u0000\u0000\u0000\u04b3\u04b4\u0001\u0000"+
		"\u0000\u0000\u04b4\u04b5\u0001\u0000\u0000\u0000\u04b5\u04b6\u0005U\u0000"+
		"\u0000\u04b6\u04b7\u0003j5\u0000\u04b7\u04c1\u0001\u0000\u0000\u0000\u04b8"+
		"\u04b9\u0005&\u0000\u0000\u04b9\u04ba\u0005T\u0000\u0000\u04ba\u04bb\u0003"+
		"|>\u0000\u04bb\u04bc\u0005{\u0000\u0000\u04bc\u04bd\u0003~?\u0000\u04bd"+
		"\u04be\u0005U\u0000\u0000\u04be\u04bf\u0003j5\u0000\u04bf\u04c1\u0001"+
		"\u0000\u0000\u0000\u04c0\u049d\u0001\u0000\u0000\u0000\u04c0\u04a3\u0001"+
		"\u0000\u0000\u0000\u04c0\u04ab\u0001\u0000\u0000\u0000\u04c0\u04b8\u0001"+
		"\u0000\u0000\u0000\u04c1y\u0001\u0000\u0000\u0000\u04c2\u04c5\u0003n7"+
		"\u0000\u04c3\u04c5\u0003\u008cF\u0000\u04c4\u04c2\u0001\u0000\u0000\u0000"+
		"\u04c4\u04c3\u0001\u0000\u0000\u0000\u04c5{\u0001\u0000\u0000\u0000\u04c6"+
		"\u04c8\u0003\u00e0p\u0000\u04c7\u04c6\u0001\u0000\u0000\u0000\u04c7\u04c8"+
		"\u0001\u0000\u0000\u0000\u04c8\u04c9\u0001\u0000\u0000\u0000\u04c9\u04ca"+
		"\u0003\u0096K\u0000\u04ca\u04cb\u0003\u00fa}\u0000\u04cb}\u0001\u0000"+
		"\u0000\u0000\u04cc\u04cf\u0003f3\u0000\u04cd\u04cf\u0003\u012c\u0096\u0000"+
		"\u04ce\u04cc\u0001\u0000\u0000\u0000\u04ce\u04cd\u0001\u0000\u0000\u0000"+
		"\u04cf\u007f\u0001\u0000\u0000\u0000\u04d0\u04d1\u0005\r\u0000\u0000\u04d1"+
		"\u04e1\u0005}\u0000\u0000\u04d2\u04d3\u0005\u0017\u0000\u0000\u04d3\u04e1"+
		"\u0005}\u0000\u0000\u04d4\u04d6\u00059\u0000\u0000\u04d5\u04d7\u0003f"+
		"3\u0000\u04d6\u04d5\u0001\u0000\u0000\u0000\u04d6\u04d7\u0001\u0000\u0000"+
		"\u0000\u04d7\u04d8\u0001\u0000\u0000\u0000\u04d8\u04e1\u0005}\u0000\u0000"+
		"\u04d9\u04da\u00059\u0000\u0000\u04da\u04db\u0003\u012c\u0096\u0000\u04db"+
		"\u04dc\u0005}\u0000\u0000\u04dc\u04e1\u0001\u0000\u0000\u0000\u04dd\u04de"+
		"\u0005(\u0000\u0000\u04de\u04df\u0005\u0081\u0000\u0000\u04df\u04e1\u0005"+
		"}\u0000\u0000\u04e0\u04d0\u0001\u0000\u0000\u0000\u04e0\u04d2\u0001\u0000"+
		"\u0000\u0000\u04e0\u04d4\u0001\u0000\u0000\u0000\u04e0\u04d9\u0001\u0000"+
		"\u0000\u0000\u04e0\u04dd\u0001\u0000\u0000\u0000\u04e1\u0081\u0001\u0000"+
		"\u0000\u0000\u04e2\u04e3\u0003\u0088D\u0000\u04e3\u0083\u0001\u0000\u0000"+
		"\u0000\u04e4\u04e5\u0006B\uffff\uffff\u0000\u04e5\u04e6\u0003\u0086C\u0000"+
		"\u04e6\u04eb\u0001\u0000\u0000\u0000\u04e7\u04e8\n\u0001\u0000\u0000\u04e8"+
		"\u04ea\u0003\u0086C\u0000\u04e9\u04e7\u0001\u0000\u0000\u0000\u04ea\u04ed"+
		"\u0001\u0000\u0000\u0000\u04eb\u04e9\u0001\u0000\u0000\u0000\u04eb\u04ec"+
		"\u0001\u0000\u0000\u0000\u04ec\u0085\u0001\u0000\u0000\u0000\u04ed\u04eb"+
		"\u0001\u0000\u0000\u0000\u04ee\u04f8\u0003\u0088D\u0000\u04ef\u04f8\u0003"+
		"\u0120\u0090\u0000\u04f0\u04f8\u0003\u0174\u00ba\u0000\u04f1\u04f8\u0003"+
		"\u0188\u00c4\u0000\u04f2\u04f8\u0003\u018a\u00c5\u0000\u04f3\u04f8\u0003"+
		"\u00deo\u0000\u04f4\u04f8\u0003\u00c6c\u0000\u04f5\u04f8\u0003\u0090H"+
		"\u0000\u04f6\u04f8\u0003\u0092I\u0000\u04f7\u04ee\u0001\u0000\u0000\u0000"+
		"\u04f7\u04ef\u0001\u0000\u0000\u0000\u04f7\u04f0\u0001\u0000\u0000\u0000"+
		"\u04f7\u04f1\u0001\u0000\u0000\u0000\u04f7\u04f2\u0001\u0000\u0000\u0000"+
		"\u04f7\u04f3\u0001\u0000\u0000\u0000\u04f7\u04f4\u0001\u0000\u0000\u0000"+
		"\u04f7\u04f5\u0001\u0000\u0000\u0000\u04f7\u04f6\u0001\u0000\u0000\u0000"+
		"\u04f8\u0087\u0001\u0000\u0000\u0000\u04f9\u0502\u0003\u008cF\u0000\u04fa"+
		"\u0502\u0003\u00dcn\u0000\u04fb\u0502\u0003\u00d4j\u0000\u04fc\u0502\u0003"+
		"\u00d8l\u0000\u04fd\u0502\u0003\u00dam\u0000\u04fe\u0502\u0003\u008eG"+
		"\u0000\u04ff\u0502\u0003\u008aE\u0000\u0500\u0502\u0003\u00b6[\u0000\u0501"+
		"\u04f9\u0001\u0000\u0000\u0000\u0501\u04fa\u0001\u0000\u0000\u0000\u0501"+
		"\u04fb\u0001\u0000\u0000\u0000\u0501\u04fc\u0001\u0000\u0000\u0000\u0501"+
		"\u04fd\u0001\u0000\u0000\u0000\u0501\u04fe\u0001\u0000\u0000\u0000\u0501"+
		"\u04ff\u0001\u0000\u0000\u0000\u0501\u0500\u0001\u0000\u0000\u0000\u0502"+
		"\u0089\u0001\u0000\u0000\u0000\u0503\u0504\u0005M\u0000\u0000\u0504\u0506"+
		"\u0005\u0081\u0000\u0000\u0505\u0507\u0003\u00e0p\u0000\u0506\u0505\u0001"+
		"\u0000\u0000\u0000\u0506\u0507\u0001\u0000\u0000\u0000\u0507\u0508\u0001"+
		"\u0000\u0000\u0000\u0508\u0509\u0005d\u0000\u0000\u0509\u050a\u0003\u010e"+
		"\u0087\u0000\u050a\u050b\u0005}\u0000\u0000\u050b\u008b\u0001\u0000\u0000"+
		"\u0000\u050c\u050e\u0003\u0096K\u0000\u050d\u050c\u0001\u0000\u0000\u0000"+
		"\u050d\u050e\u0001\u0000\u0000\u0000\u050e\u0510\u0001\u0000\u0000\u0000"+
		"\u050f\u0511\u0003\u00f6{\u0000\u0510\u050f\u0001\u0000\u0000\u0000\u0510"+
		"\u0511\u0001\u0000\u0000\u0000\u0511\u0512\u0001\u0000\u0000\u0000\u0512"+
		"\u051b\u0005}\u0000\u0000\u0513\u0515\u0003\u00e0p\u0000\u0514\u0516\u0003"+
		"\u0096K\u0000\u0515\u0514\u0001\u0000\u0000\u0000\u0515\u0516\u0001\u0000"+
		"\u0000\u0000\u0516\u0517\u0001\u0000\u0000\u0000\u0517\u0518\u0003\u00f6"+
		"{\u0000\u0518\u0519\u0005}\u0000\u0000\u0519\u051b\u0001\u0000\u0000\u0000"+
		"\u051a\u050d\u0001\u0000\u0000\u0000\u051a\u0513\u0001\u0000\u0000\u0000"+
		"\u051b\u008d\u0001\u0000\u0000\u0000\u051c\u051d\u0005>\u0000\u0000\u051d"+
		"\u051e\u0005T\u0000\u0000\u051e\u051f\u0003h4\u0000\u051f\u0520\u0005"+
		"w\u0000\u0000\u0520\u0521\u0005\u008a\u0000\u0000\u0521\u0522\u0005U\u0000"+
		"\u0000\u0522\u0523\u0005}\u0000\u0000\u0523\u008f\u0001\u0000\u0000\u0000"+
		"\u0524\u0525\u0005}\u0000\u0000\u0525\u0091\u0001\u0000\u0000\u0000\u0526"+
		"\u0527\u0003\u00e0p\u0000\u0527\u0528\u0005}\u0000\u0000\u0528\u0093\u0001"+
		"\u0000\u0000\u0000\u0529\u0530\u0003\u0098L\u0000\u052a\u0530\u0003\u00a0"+
		"P\u0000\u052b\u0530\u0003\u009aM\u0000\u052c\u0530\u0005\'\u0000\u0000"+
		"\u052d\u0530\u0005H\u0000\u0000\u052e\u0530\u0005\u0015\u0000\u0000\u052f"+
		"\u0529\u0001\u0000\u0000\u0000\u052f\u052a\u0001\u0000\u0000\u0000\u052f"+
		"\u052b\u0001\u0000\u0000\u0000\u052f\u052c\u0001\u0000\u0000\u0000\u052f"+
		"\u052d\u0001\u0000\u0000\u0000\u052f\u052e\u0001\u0000\u0000\u0000\u0530"+
		"\u0095\u0001\u0000\u0000\u0000\u0531\u0533\u0003\u0094J\u0000\u0532\u0534"+
		"\u0003\u00e0p\u0000\u0533\u0532\u0001\u0000\u0000\u0000\u0533\u0534\u0001"+
		"\u0000\u0000\u0000\u0534\u0539\u0001\u0000\u0000\u0000\u0535\u0536\u0003"+
		"\u0094J\u0000\u0536\u0537\u0003\u0096K\u0000\u0537\u0539\u0001\u0000\u0000"+
		"\u0000\u0538\u0531\u0001\u0000\u0000\u0000\u0538\u0535\u0001\u0000\u0000"+
		"\u0000\u0539\u0097\u0001\u0000\u0000\u0000\u053a\u053b\u0007\u0002\u0000"+
		"\u0000\u053b\u0099\u0001\u0000\u0000\u0000\u053c\u053d\u0007\u0003\u0000"+
		"\u0000\u053d\u009b\u0001\u0000\u0000\u0000\u053e\u053f\u0005\u0081\u0000"+
		"\u0000\u053f\u009d\u0001\u0000\u0000\u0000\u0540\u0541\u0005\u0081\u0000"+
		"\u0000\u0541\u009f\u0001\u0000\u0000\u0000\u0542\u0549\u0003\u00a2Q\u0000"+
		"\u0543\u0549\u0003\u0138\u009c\u0000\u0544\u0549\u0003\u00b2Y\u0000\u0545"+
		"\u0549\u0003\u013a\u009d\u0000\u0546\u0549\u0003\u0130\u0098\u0000\u0547"+
		"\u0549\u0003\u0134\u009a\u0000\u0548\u0542\u0001\u0000\u0000\u0000\u0548"+
		"\u0543\u0001\u0000\u0000\u0000\u0548\u0544\u0001\u0000\u0000\u0000\u0548"+
		"\u0545\u0001\u0000\u0000\u0000\u0548\u0546\u0001\u0000\u0000\u0000\u0548"+
		"\u0547\u0001\u0000\u0000\u0000\u0549\u00a1\u0001\u0000\u0000\u0000\u054a"+
		"\u054f\u0003\u00a8T\u0000\u054b\u054f\u0003\u00aeW\u0000\u054c\u054f\u0003"+
		"\u0186\u00c3\u0000\u054d\u054f\u0003\u0108\u0084\u0000\u054e\u054a\u0001"+
		"\u0000\u0000\u0000\u054e\u054b\u0001\u0000\u0000\u0000\u054e\u054c\u0001"+
		"\u0000\u0000\u0000\u054e\u054d\u0001\u0000\u0000\u0000\u054f\u00a3\u0001"+
		"\u0000\u0000\u0000\u0550\u0552\u0003\u00a0P\u0000\u0551\u0553\u0003\u00e0"+
		"p\u0000\u0552\u0551\u0001\u0000\u0000\u0000\u0552\u0553\u0001\u0000\u0000"+
		"\u0000\u0553\u0558\u0001\u0000\u0000\u0000\u0554\u0555\u0003\u00a0P\u0000"+
		"\u0555\u0556\u0003\u00a4R\u0000\u0556\u0558\u0001\u0000\u0000\u0000\u0557"+
		"\u0550\u0001\u0000\u0000\u0000\u0557\u0554\u0001\u0000\u0000\u0000\u0558"+
		"\u00a5\u0001\u0000\u0000\u0000\u0559\u055b\u0003\u00a2Q\u0000\u055a\u055c"+
		"\u0003\u00e0p\u0000\u055b\u055a\u0001\u0000\u0000\u0000\u055b\u055c\u0001"+
		"\u0000\u0000\u0000\u055c\u0561\u0001\u0000\u0000\u0000\u055d\u055e\u0003"+
		"\u00a2Q\u0000\u055e\u055f\u0003\u00a6S\u0000\u055f\u0561\u0001\u0000\u0000"+
		"\u0000\u0560\u0559\u0001\u0000\u0000\u0000\u0560\u055d\u0001\u0000\u0000"+
		"\u0000\u0561\u00a7\u0001\u0000\u0000\u0000\u0562\u0564\u0003\n\u0005\u0000"+
		"\u0563\u0562\u0001\u0000\u0000\u0000\u0563\u0564\u0001\u0000\u0000\u0000"+
		"\u0564\u0566\u0001\u0000\u0000\u0000\u0565\u0567\u0005H\u0000\u0000\u0566"+
		"\u0565\u0001\u0000\u0000\u0000\u0566\u0567\u0001\u0000\u0000\u0000\u0567"+
		"\u0568\u0001\u0000\u0000\u0000\u0568\u057e\u0003\u00aaU\u0000\u0569\u056a"+
		"\u0003\n\u0005\u0000\u056a\u056b\u0005B\u0000\u0000\u056b\u056c\u0003"+
		"\u017c\u00be\u0000\u056c\u057e\u0001\u0000\u0000\u0000\u056d\u057e\u0005"+
		"\u0010\u0000\u0000\u056e\u057e\u0005\u0011\u0000\u0000\u056f\u057e\u0005"+
		"\u0012\u0000\u0000\u0570\u057e\u0005Q\u0000\u0000\u0571\u057e\u0005\f"+
		"\u0000\u0000\u0572\u057e\u0005:\u0000\u0000\u0573\u057e\u0005+\u0000\u0000"+
		"\u0574\u057e\u0005,\u0000\u0000\u0575\u057e\u0005;\u0000\u0000\u0576\u057e"+
		"\u0005L\u0000\u0000\u0577\u057e\u0005%\u0000\u0000\u0578\u057e\u0005\u001c"+
		"\u0000\u0000\u0579\u057e\u0005O\u0000\u0000\u057a\u057e\u0005\u000b\u0000"+
		"\u0000\u057b\u057e\u0005@\u0000\u0000\u057c\u057e\u0003\u00acV\u0000\u057d"+
		"\u0563\u0001\u0000\u0000\u0000\u057d\u0569\u0001\u0000\u0000\u0000\u057d"+
		"\u056d\u0001\u0000\u0000\u0000\u057d\u056e\u0001\u0000\u0000\u0000\u057d"+
		"\u056f\u0001\u0000\u0000\u0000\u057d\u0570\u0001\u0000\u0000\u0000\u057d"+
		"\u0571\u0001\u0000\u0000\u0000\u057d\u0572\u0001\u0000\u0000\u0000\u057d"+
		"\u0573\u0001\u0000\u0000\u0000\u057d\u0574\u0001\u0000\u0000\u0000\u057d"+
		"\u0575\u0001\u0000\u0000\u0000\u057d\u0576\u0001\u0000\u0000\u0000\u057d"+
		"\u0577\u0001\u0000\u0000\u0000\u057d\u0578\u0001\u0000\u0000\u0000\u057d"+
		"\u0579\u0001\u0000\u0000\u0000\u057d\u057a\u0001\u0000\u0000\u0000\u057d"+
		"\u057b\u0001\u0000\u0000\u0000\u057d\u057c\u0001\u0000\u0000\u0000\u057e"+
		"\u00a9\u0001\u0000\u0000\u0000\u057f\u0584\u0003\u012e\u0097\u0000\u0580"+
		"\u0584\u0003\u00b0X\u0000\u0581\u0584\u0003\u009cN\u0000\u0582\u0584\u0003"+
		"\u017c\u00be\u0000\u0583\u057f\u0001\u0000\u0000\u0000\u0583\u0580\u0001"+
		"\u0000\u0000\u0000\u0583\u0581\u0001\u0000\u0000\u0000\u0583\u0582\u0001"+
		"\u0000\u0000\u0000\u0584\u00ab\u0001\u0000\u0000\u0000\u0585\u0586\u0005"+
		"\u0018\u0000\u0000\u0586\u0587\u0005T\u0000\u0000\u0587\u0588\u0003f3"+
		"\u0000\u0588\u0589\u0005U\u0000\u0000\u0589\u058f\u0001\u0000\u0000\u0000"+
		"\u058a\u058b\u0005\u0018\u0000\u0000\u058b\u058c\u0005T\u0000\u0000\u058c"+
		"\u058d\u0005\u000b\u0000\u0000\u058d\u058f\u0005U\u0000\u0000\u058e\u0585"+
		"\u0001\u0000\u0000\u0000\u058e\u058a\u0001\u0000\u0000\u0000\u058f\u00ad"+
		"\u0001\u0000\u0000\u0000\u0590\u0592\u0003\u0144\u00a2\u0000\u0591\u0593"+
		"\u0003\u00e0p\u0000\u0592\u0591\u0001\u0000\u0000\u0000\u0592\u0593\u0001"+
		"\u0000\u0000\u0000\u0593\u0595\u0001\u0000\u0000\u0000\u0594\u0596\u0003"+
		"\n\u0005\u0000\u0595\u0594\u0001\u0000\u0000\u0000\u0595\u0596\u0001\u0000"+
		"\u0000\u0000\u0596\u0597\u0001\u0000\u0000\u0000\u0597\u0598\u0005\u0081"+
		"\u0000\u0000\u0598\u05ac\u0001\u0000\u0000\u0000\u0599\u059b\u0005B\u0000"+
		"\u0000\u059a\u0599\u0001\u0000\u0000\u0000\u059a\u059b\u0001\u0000\u0000"+
		"\u0000\u059b\u059c\u0001\u0000\u0000\u0000\u059c\u059d\u0003\u0144\u00a2"+
		"\u0000\u059d\u059e\u0003\u017c\u00be\u0000\u059e\u05ac\u0001\u0000\u0000"+
		"\u0000\u059f\u05a0\u0003\u0144\u00a2\u0000\u05a0\u05a2\u0003\n\u0005\u0000"+
		"\u05a1\u05a3\u0005B\u0000\u0000\u05a2\u05a1\u0001\u0000\u0000\u0000\u05a2"+
		"\u05a3\u0001\u0000\u0000\u0000\u05a3\u05a4\u0001\u0000\u0000\u0000\u05a4"+
		"\u05a5\u0003\u017c\u00be\u0000\u05a5\u05ac\u0001\u0000\u0000\u0000\u05a6"+
		"\u05a8\u0005\u001f\u0000\u0000\u05a7\u05a9\u0003\n\u0005\u0000\u05a8\u05a7"+
		"\u0001\u0000\u0000\u0000\u05a8\u05a9\u0001\u0000\u0000\u0000\u05a9\u05aa"+
		"\u0001\u0000\u0000\u0000\u05aa\u05ac\u0005\u0081\u0000\u0000\u05ab\u0590"+
		"\u0001\u0000\u0000\u0000\u05ab\u059a\u0001\u0000\u0000\u0000\u05ab\u059f"+
		"\u0001\u0000\u0000\u0000\u05ab\u05a6\u0001\u0000\u0000\u0000\u05ac\u00af"+
		"\u0001\u0000\u0000\u0000\u05ad\u05ae\u0005\u0081\u0000\u0000\u05ae\u00b1"+
		"\u0001\u0000\u0000\u0000\u05af\u05b0\u0003\u00b4Z\u0000\u05b0\u05b2\u0005"+
		"X\u0000\u0000\u05b1\u05b3\u0003\u00bc^\u0000\u05b2\u05b1\u0001\u0000\u0000"+
		"\u0000\u05b2\u05b3\u0001\u0000\u0000\u0000\u05b3\u05b4\u0001\u0000\u0000"+
		"\u0000\u05b4\u05b5\u0005Y\u0000\u0000\u05b5\u05bd\u0001\u0000\u0000\u0000"+
		"\u05b6\u05b7\u0003\u00b4Z\u0000\u05b7\u05b8\u0005X\u0000\u0000\u05b8\u05b9"+
		"\u0003\u00bc^\u0000\u05b9\u05ba\u0005w\u0000\u0000\u05ba\u05bb\u0005Y"+
		"\u0000\u0000\u05bb\u05bd\u0001\u0000\u0000\u0000\u05bc\u05af\u0001\u0000"+
		"\u0000\u0000\u05bc\u05b6\u0001\u0000\u0000\u0000\u05bd\u00b3\u0001\u0000"+
		"\u0000\u0000\u05be\u05c0\u0003\u00b8\\\u0000\u05bf\u05c1\u0003\u00e0p"+
		"\u0000\u05c0\u05bf\u0001\u0000\u0000\u0000\u05c0\u05c1\u0001\u0000\u0000"+
		"\u0000\u05c1\u05c3\u0001\u0000\u0000\u0000\u05c2\u05c4\u0005\u0081\u0000"+
		"\u0000\u05c3\u05c2\u0001\u0000\u0000\u0000\u05c3\u05c4\u0001\u0000\u0000"+
		"\u0000\u05c4\u05c6\u0001\u0000\u0000\u0000\u05c5\u05c7\u0003\u00ba]\u0000"+
		"\u05c6\u05c5\u0001\u0000\u0000\u0000\u05c6\u05c7\u0001\u0000\u0000\u0000"+
		"\u05c7\u05d2\u0001\u0000\u0000\u0000\u05c8\u05ca\u0003\u00b8\\\u0000\u05c9"+
		"\u05cb\u0003\u00e0p\u0000\u05ca\u05c9\u0001\u0000\u0000\u0000\u05ca\u05cb"+
		"\u0001\u0000\u0000\u0000\u05cb\u05cc\u0001\u0000\u0000\u0000\u05cc\u05cd"+
		"\u0003\n\u0005\u0000\u05cd\u05cf\u0005\u0081\u0000\u0000\u05ce\u05d0\u0003"+
		"\u00ba]\u0000\u05cf\u05ce\u0001\u0000\u0000\u0000\u05cf\u05d0\u0001\u0000"+
		"\u0000\u0000\u05d0\u05d2\u0001\u0000\u0000\u0000\u05d1\u05be\u0001\u0000"+
		"\u0000\u0000\u05d1\u05c8\u0001\u0000\u0000\u0000\u05d2\u00b5\u0001\u0000"+
		"\u0000\u0000\u05d3\u05d5\u0003\u00b8\\\u0000\u05d4\u05d6\u0003\u00e0p"+
		"\u0000\u05d5\u05d4\u0001\u0000\u0000\u0000\u05d5\u05d6\u0001\u0000\u0000"+
		"\u0000\u05d6\u05d7\u0001\u0000\u0000\u0000\u05d7\u05d9\u0005\u0081\u0000"+
		"\u0000\u05d8\u05da\u0003\u00ba]\u0000\u05d9\u05d8\u0001\u0000\u0000\u0000"+
		"\u05d9\u05da\u0001\u0000\u0000\u0000\u05da\u05db\u0001\u0000\u0000\u0000"+
		"\u05db\u05dc\u0005}\u0000\u0000\u05dc\u00b7\u0001\u0000\u0000\u0000\u05dd"+
		"\u05e3\u0005\u001f\u0000\u0000\u05de\u05df\u0005\u001f\u0000\u0000\u05df"+
		"\u05e3\u0005\u0013\u0000\u0000\u05e0\u05e1\u0005\u001f\u0000\u0000\u05e1"+
		"\u05e3\u0005@\u0000\u0000\u05e2\u05dd\u0001\u0000\u0000\u0000\u05e2\u05de"+
		"\u0001\u0000\u0000\u0000\u05e2\u05e0\u0001\u0000\u0000\u0000\u05e3\u00b9"+
		"\u0001\u0000\u0000\u0000\u05e4\u05e5\u0005{\u0000\u0000\u05e5\u05e6\u0003"+
		"\u00a4R\u0000\u05e6\u00bb\u0001\u0000\u0000\u0000\u05e7\u05e8\u0006^\uffff"+
		"\uffff\u0000\u05e8\u05e9\u0003\u00be_\u0000\u05e9\u05ef\u0001\u0000\u0000"+
		"\u0000\u05ea\u05eb\n\u0001\u0000\u0000\u05eb\u05ec\u0005w\u0000\u0000"+
		"\u05ec\u05ee\u0003\u00be_\u0000\u05ed\u05ea\u0001\u0000\u0000\u0000\u05ee"+
		"\u05f1\u0001\u0000\u0000\u0000\u05ef\u05ed\u0001\u0000\u0000\u0000\u05ef"+
		"\u05f0\u0001\u0000\u0000\u0000\u05f0\u00bd\u0001\u0000\u0000\u0000\u05f1"+
		"\u05ef\u0001\u0000\u0000\u0000\u05f2\u05f8\u0003\u00c0`\u0000\u05f3\u05f4"+
		"\u0003\u00c0`\u0000\u05f4\u05f5\u0005d\u0000\u0000\u05f5\u05f6\u0003h"+
		"4\u0000\u05f6\u05f8\u0001\u0000\u0000\u0000\u05f7\u05f2\u0001\u0000\u0000"+
		"\u0000\u05f7\u05f3\u0001\u0000\u0000\u0000\u05f8\u00bf\u0001\u0000\u0000"+
		"\u0000\u05f9\u05fa\u0005\u0081\u0000\u0000\u05fa\u00c1\u0001\u0000\u0000"+
		"\u0000\u05fb\u05fe\u0003\u00c4b\u0000\u05fc\u05fe\u0003\u00d2i\u0000\u05fd"+
		"\u05fb\u0001\u0000\u0000\u0000\u05fd\u05fc\u0001\u0000\u0000\u0000\u05fe"+
		"\u00c3\u0001\u0000\u0000\u0000\u05ff\u0600\u0005\u0081\u0000\u0000\u0600"+
		"\u00c5\u0001\u0000\u0000\u0000\u0601\u0604\u0003\u00c8d\u0000\u0602\u0604"+
		"\u0003\u00ceg\u0000\u0603\u0601\u0001\u0000\u0000\u0000\u0603\u0602\u0001"+
		"\u0000\u0000\u0000\u0604\u00c7\u0001\u0000\u0000\u0000\u0605\u0608\u0003"+
		"\u00cae\u0000\u0606\u0608\u0003\u00ccf\u0000\u0607\u0605\u0001\u0000\u0000"+
		"\u0000\u0607\u0606\u0001\u0000\u0000\u0000\u0608\u00c9\u0001\u0000\u0000"+
		"\u0000\u0609\u060b\u0005*\u0000\u0000\u060a\u0609\u0001\u0000\u0000\u0000"+
		"\u060a\u060b\u0001\u0000\u0000\u0000\u060b\u060c\u0001\u0000\u0000\u0000"+
		"\u060c\u060d\u0005.\u0000\u0000\u060d\u060e\u0005\u0081\u0000\u0000\u060e"+
		"\u060f\u0005X\u0000\u0000\u060f\u0610\u0003\u00d0h\u0000\u0610\u0611\u0005"+
		"Y\u0000\u0000\u0611\u00cb\u0001\u0000\u0000\u0000\u0612\u0614\u0005*\u0000"+
		"\u0000\u0613\u0612\u0001\u0000\u0000\u0000\u0613\u0614\u0001\u0000\u0000"+
		"\u0000\u0614\u0615\u0001\u0000\u0000\u0000\u0615\u0616\u0005.\u0000\u0000"+
		"\u0616\u0617\u0003\u00c4b\u0000\u0617\u0618\u0005X\u0000\u0000\u0618\u0619"+
		"\u0003\u00d0h\u0000\u0619\u061a\u0005Y\u0000\u0000\u061a\u00cd\u0001\u0000"+
		"\u0000\u0000\u061b\u061d\u0005*\u0000\u0000\u061c\u061b\u0001\u0000\u0000"+
		"\u0000\u061c\u061d\u0001\u0000\u0000\u0000\u061d\u061e\u0001\u0000\u0000"+
		"\u0000\u061e\u061f\u0005.\u0000\u0000\u061f\u0620\u0005X\u0000\u0000\u0620"+
		"\u0621\u0003\u00d0h\u0000\u0621\u0622\u0005Y\u0000\u0000\u0622\u00cf\u0001"+
		"\u0000\u0000\u0000\u0623\u0625\u0003\u0084B\u0000\u0624\u0623\u0001\u0000"+
		"\u0000\u0000\u0624\u0625\u0001\u0000\u0000\u0000\u0625\u00d1\u0001\u0000"+
		"\u0000\u0000\u0626\u0627\u0005\u0081\u0000\u0000\u0627\u00d3\u0001\u0000"+
		"\u0000\u0000\u0628\u0629\u0005.\u0000\u0000\u0629\u062a\u0005\u0081\u0000"+
		"\u0000\u062a\u062b\u0005d\u0000\u0000\u062b\u062c\u0003\u00d6k\u0000\u062c"+
		"\u062d\u0005}\u0000\u0000\u062d\u00d5\u0001\u0000\u0000\u0000\u062e\u0630"+
		"\u0003\n\u0005\u0000\u062f\u062e\u0001\u0000\u0000\u0000\u062f\u0630\u0001"+
		"\u0000\u0000\u0000\u0630\u0631\u0001\u0000\u0000\u0000\u0631\u0632\u0003"+
		"\u00c2a\u0000\u0632\u00d7\u0001\u0000\u0000\u0000\u0633\u0635\u0005M\u0000"+
		"\u0000\u0634\u0636\u0005J\u0000\u0000\u0635\u0634\u0001\u0000\u0000\u0000"+
		"\u0635\u0636\u0001\u0000\u0000\u0000\u0636\u0637\u0001\u0000\u0000\u0000"+
		"\u0637\u0638\u0003\n\u0005\u0000\u0638\u0639\u0003\u0006\u0003\u0000\u0639"+
		"\u063a\u0005}\u0000\u0000\u063a\u0641\u0001\u0000\u0000\u0000\u063b\u063c"+
		"\u0005M\u0000\u0000\u063c\u063d\u0005|\u0000\u0000\u063d\u063e\u0003\u0006"+
		"\u0003\u0000\u063e\u063f\u0005}\u0000\u0000\u063f\u0641\u0001\u0000\u0000"+
		"\u0000\u0640\u0633\u0001\u0000\u0000\u0000\u0640\u063b\u0001\u0000\u0000"+
		"\u0000\u0641\u00d9\u0001\u0000\u0000\u0000\u0642\u0644\u0003\u00e0p\u0000"+
		"\u0643\u0642\u0001\u0000\u0000\u0000\u0643\u0644\u0001\u0000\u0000\u0000"+
		"\u0644\u0645\u0001\u0000\u0000\u0000\u0645\u0646\u0005M\u0000\u0000\u0646"+
		"\u0648\u0005.\u0000\u0000\u0647\u0649\u0003\n\u0005\u0000\u0648\u0647"+
		"\u0001\u0000\u0000\u0000\u0648\u0649\u0001\u0000\u0000\u0000\u0649\u064a"+
		"\u0001\u0000\u0000\u0000\u064a\u064b\u0003\u00c2a\u0000\u064b\u064c\u0005"+
		"}\u0000\u0000\u064c\u00db\u0001\u0000\u0000\u0000\u064d\u064e\u0005\n"+
		"\u0000\u0000\u064e\u064f\u0005T\u0000\u0000\u064f\u0650\u0005\u008a\u0000"+
		"\u0000\u0650\u0651\u0005U\u0000\u0000\u0651\u0652\u0005}\u0000\u0000\u0652"+
		"\u00dd\u0001\u0000\u0000\u0000\u0653\u0654\u0005\"\u0000\u0000\u0654\u0655"+
		"\u0005\u008a\u0000\u0000\u0655\u0657\u0005X\u0000\u0000\u0656\u0658\u0003"+
		"\u0084B\u0000\u0657\u0656\u0001\u0000\u0000\u0000\u0657\u0658\u0001\u0000"+
		"\u0000\u0000\u0658\u0659\u0001\u0000\u0000\u0000\u0659\u065e\u0005Y\u0000"+
		"\u0000\u065a\u065b\u0005\"\u0000\u0000\u065b\u065c\u0005\u008a\u0000\u0000"+
		"\u065c\u065e\u0003\u0086C\u0000\u065d\u0653\u0001\u0000\u0000\u0000\u065d"+
		"\u065a\u0001\u0000\u0000\u0000\u065e\u00df\u0001\u0000\u0000\u0000\u065f"+
		"\u0660\u0006p\uffff\uffff\u0000\u0660\u0661\u0003\u00e2q\u0000\u0661\u0666"+
		"\u0001\u0000\u0000\u0000\u0662\u0663\n\u0001\u0000\u0000\u0663\u0665\u0003"+
		"\u00e2q\u0000\u0664\u0662\u0001\u0000\u0000\u0000\u0665\u0668\u0001\u0000"+
		"\u0000\u0000\u0666\u0664\u0001\u0000\u0000\u0000\u0666\u0667\u0001\u0000"+
		"\u0000\u0000\u0667\u00e1\u0001\u0000\u0000\u0000\u0668\u0666\u0001\u0000"+
		"\u0000\u0000\u0669\u066a\u0005V\u0000\u0000\u066a\u066b\u0005V\u0000\u0000"+
		"\u066b\u066c\u0003\u00e6s\u0000\u066c\u066d\u0005W\u0000\u0000\u066d\u066e"+
		"\u0005W\u0000\u0000\u066e\u0671\u0001\u0000\u0000\u0000\u066f\u0671\u0003"+
		"\u00e4r\u0000\u0670\u0669\u0001\u0000\u0000\u0000\u0670\u066f\u0001\u0000"+
		"\u0000\u0000\u0671\u00e3\u0001\u0000\u0000\u0000\u0672\u0673\u0005\b\u0000"+
		"\u0000\u0673\u0674\u0005T\u0000\u0000\u0674\u0676\u0003\u010e\u0087\u0000"+
		"\u0675\u0677\u0005\u0080\u0000\u0000\u0676\u0675\u0001\u0000\u0000\u0000"+
		"\u0676\u0677\u0001\u0000\u0000\u0000\u0677\u0678\u0001\u0000\u0000\u0000"+
		"\u0678\u0679\u0005U\u0000\u0000\u0679\u0683\u0001\u0000\u0000\u0000\u067a"+
		"\u067b\u0005\b\u0000\u0000\u067b\u067c\u0005T\u0000\u0000\u067c\u067e"+
		"\u0003h4\u0000\u067d\u067f\u0005\u0080\u0000\u0000\u067e\u067d\u0001\u0000"+
		"\u0000\u0000\u067e\u067f\u0001\u0000\u0000\u0000\u067f\u0680\u0001\u0000"+
		"\u0000\u0000\u0680\u0681\u0005U\u0000\u0000\u0681\u0683\u0001\u0000\u0000"+
		"\u0000\u0682\u0672\u0001\u0000\u0000\u0000\u0682\u067a\u0001\u0000\u0000"+
		"\u0000\u0683\u00e5\u0001\u0000\u0000\u0000\u0684\u0686\u0006s\uffff\uffff"+
		"\u0000\u0685\u0687\u0003\u00e8t\u0000\u0686\u0685\u0001\u0000\u0000\u0000"+
		"\u0686\u0687\u0001\u0000\u0000\u0000\u0687\u068c\u0001\u0000\u0000\u0000"+
		"\u0688\u0689\u0003\u00e8t\u0000\u0689\u068a\u0005\u0080\u0000\u0000\u068a"+
		"\u068c\u0001\u0000\u0000\u0000\u068b\u0684\u0001\u0000\u0000\u0000\u068b"+
		"\u0688\u0001\u0000\u0000\u0000\u068c\u0699\u0001\u0000\u0000\u0000\u068d"+
		"\u068e\n\u0003\u0000\u0000\u068e\u0690\u0005w\u0000\u0000\u068f\u0691"+
		"\u0003\u00e8t\u0000\u0690\u068f\u0001\u0000\u0000\u0000\u0690\u0691\u0001"+
		"\u0000\u0000\u0000\u0691\u0698\u0001\u0000\u0000\u0000\u0692\u0693\n\u0001"+
		"\u0000\u0000\u0693\u0694\u0005w\u0000\u0000\u0694\u0695\u0003\u00e8t\u0000"+
		"\u0695\u0696\u0005\u0080\u0000\u0000\u0696\u0698\u0001\u0000\u0000\u0000"+
		"\u0697\u068d\u0001\u0000\u0000\u0000\u0697\u0692\u0001\u0000\u0000\u0000"+
		"\u0698\u069b\u0001\u0000\u0000\u0000\u0699\u0697\u0001\u0000\u0000\u0000"+
		"\u0699\u069a\u0001\u0000\u0000\u0000\u069a\u00e7\u0001\u0000\u0000\u0000"+
		"\u069b\u0699\u0001\u0000\u0000\u0000\u069c\u069e\u0003\u00eau\u0000\u069d"+
		"\u069f\u0003\u00f0x\u0000\u069e\u069d\u0001\u0000\u0000\u0000\u069e\u069f"+
		"\u0001\u0000\u0000\u0000\u069f\u00e9\u0001\u0000\u0000\u0000\u06a0\u06a3"+
		"\u0005\u0081\u0000\u0000\u06a1\u06a3\u0003\u00ecv\u0000\u06a2\u06a0\u0001"+
		"\u0000\u0000\u0000\u06a2\u06a1\u0001\u0000\u0000\u0000\u06a3\u00eb\u0001"+
		"\u0000\u0000\u0000\u06a4\u06a5\u0003\u00eew\u0000\u06a5\u06a6\u0005|\u0000"+
		"\u0000\u06a6\u06a7\u0005\u0081\u0000\u0000\u06a7\u00ed\u0001\u0000\u0000"+
		"\u0000\u06a8\u06a9\u0005\u0081\u0000\u0000\u06a9\u00ef\u0001\u0000\u0000"+
		"\u0000\u06aa\u06ab\u0005T\u0000\u0000\u06ab\u06ac\u0003\u00f2y\u0000\u06ac"+
		"\u06ad\u0005U\u0000\u0000\u06ad\u00f1\u0001\u0000\u0000\u0000\u06ae\u06b0"+
		"\u0006y\uffff\uffff\u0000\u06af\u06b1\u0003\u00f4z\u0000\u06b0\u06af\u0001"+
		"\u0000\u0000\u0000\u06b0\u06b1\u0001\u0000\u0000\u0000\u06b1\u06b6\u0001"+
		"\u0000\u0000\u0000\u06b2\u06b3\n\u0001\u0000\u0000\u06b3\u06b5\u0003\u00f4"+
		"z\u0000\u06b4\u06b2\u0001\u0000\u0000\u0000\u06b5\u06b8\u0001\u0000\u0000"+
		"\u0000\u06b6\u06b4\u0001\u0000\u0000\u0000\u06b6\u06b7\u0001\u0000\u0000"+
		"\u0000\u06b7\u00f3\u0001\u0000\u0000\u0000\u06b8\u06b6\u0001\u0000\u0000"+
		"\u0000\u06b9\u06ba\u0005T\u0000\u0000\u06ba\u06bb\u0003\u00f2y\u0000\u06bb"+
		"\u06bc\u0005U\u0000\u0000\u06bc\u06cb\u0001\u0000\u0000\u0000\u06bd\u06be"+
		"\u0005V\u0000\u0000\u06be\u06bf\u0003\u00f2y\u0000\u06bf\u06c0\u0005W"+
		"\u0000\u0000\u06c0\u06cb\u0001\u0000\u0000\u0000\u06c1\u06c2\u0005X\u0000"+
		"\u0000\u06c2\u06c3\u0003\u00f2y\u0000\u06c3\u06c4\u0005Y\u0000\u0000\u06c4"+
		"\u06cb\u0001\u0000\u0000\u0000\u06c5\u06c7\b\u0004\u0000\u0000\u06c6\u06c5"+
		"\u0001\u0000\u0000\u0000\u06c7\u06c8\u0001\u0000\u0000\u0000\u06c8\u06c6"+
		"\u0001\u0000\u0000\u0000\u06c8\u06c9\u0001\u0000\u0000\u0000\u06c9\u06cb"+
		"\u0001\u0000\u0000\u0000\u06ca\u06b9\u0001\u0000\u0000\u0000\u06ca\u06bd"+
		"\u0001\u0000\u0000\u0000\u06ca\u06c1\u0001\u0000\u0000\u0000\u06ca\u06c6"+
		"\u0001\u0000\u0000\u0000\u06cb\u00f5\u0001\u0000\u0000\u0000\u06cc\u06cd"+
		"\u0006{\uffff\uffff\u0000\u06cd\u06ce\u0003\u00f8|\u0000\u06ce\u06d4\u0001"+
		"\u0000\u0000\u0000\u06cf\u06d0\n\u0001\u0000\u0000\u06d0\u06d1\u0005w"+
		"\u0000\u0000\u06d1\u06d3\u0003\u00f8|\u0000\u06d2\u06cf\u0001\u0000\u0000"+
		"\u0000\u06d3\u06d6\u0001\u0000\u0000\u0000\u06d4\u06d2\u0001\u0000\u0000"+
		"\u0000\u06d4\u06d5\u0001\u0000\u0000\u0000\u06d5\u00f7\u0001\u0000\u0000"+
		"\u0000\u06d6\u06d4\u0001\u0000\u0000\u0000\u06d7\u06d9\u0003\u00fa}\u0000"+
		"\u06d8\u06da\u0003\u0124\u0092\u0000\u06d9\u06d8\u0001\u0000\u0000\u0000"+
		"\u06d9\u06da\u0001\u0000\u0000\u0000\u06da\u00f9\u0001\u0000\u0000\u0000"+
		"\u06db\u06e1\u0003\u00fc~\u0000\u06dc\u06dd\u0003\u00fe\u007f\u0000\u06dd"+
		"\u06de\u0003\u0100\u0080\u0000\u06de\u06df\u0003\u0102\u0081\u0000\u06df"+
		"\u06e1\u0001\u0000\u0000\u0000\u06e0\u06db\u0001\u0000\u0000\u0000\u06e0"+
		"\u06dc\u0001\u0000\u0000\u0000\u06e1\u00fb\u0001\u0000\u0000\u0000\u06e2"+
		"\u06e7\u0003\u00fe\u007f\u0000\u06e3\u06e4\u0003\u0104\u0082\u0000\u06e4"+
		"\u06e5\u0003\u00fc~\u0000\u06e5\u06e7\u0001\u0000\u0000\u0000\u06e6\u06e2"+
		"\u0001\u0000\u0000\u0000\u06e6\u06e3\u0001\u0000\u0000\u0000\u06e7\u00fd"+
		"\u0001\u0000\u0000\u0000\u06e8\u06e9\u0006\u007f\uffff\uffff\u0000\u06e9"+
		"\u06eb\u0003\u010c\u0086\u0000\u06ea\u06ec\u0003\u00e0p\u0000\u06eb\u06ea"+
		"\u0001\u0000\u0000\u0000\u06eb\u06ec\u0001\u0000\u0000\u0000\u06ec\u06f2"+
		"\u0001\u0000\u0000\u0000\u06ed\u06ee\u0005T\u0000\u0000\u06ee\u06ef\u0003"+
		"\u00fc~\u0000\u06ef\u06f0\u0005U\u0000\u0000\u06f0\u06f2\u0001\u0000\u0000"+
		"\u0000\u06f1\u06e8\u0001\u0000\u0000\u0000\u06f1\u06ed\u0001\u0000\u0000"+
		"\u0000\u06f2\u0700\u0001\u0000\u0000\u0000\u06f3\u06f4\n\u0003\u0000\u0000"+
		"\u06f4\u06ff\u0003\u0100\u0080\u0000\u06f5\u06f6\n\u0002\u0000\u0000\u06f6"+
		"\u06f8\u0005V\u0000\u0000\u06f7\u06f9\u0003h4\u0000\u06f8\u06f7\u0001"+
		"\u0000\u0000\u0000\u06f8\u06f9\u0001\u0000\u0000\u0000\u06f9\u06fa\u0001"+
		"\u0000\u0000\u0000\u06fa\u06fc\u0005W\u0000\u0000\u06fb\u06fd\u0003\u00e0"+
		"p\u0000\u06fc\u06fb\u0001\u0000\u0000\u0000\u06fc\u06fd\u0001\u0000\u0000"+
		"\u0000\u06fd\u06ff\u0001\u0000\u0000\u0000\u06fe\u06f3\u0001\u0000\u0000"+
		"\u0000\u06fe\u06f5\u0001\u0000\u0000\u0000\u06ff\u0702\u0001\u0000\u0000"+
		"\u0000\u0700\u06fe\u0001\u0000\u0000\u0000\u0700\u0701\u0001\u0000\u0000"+
		"\u0000\u0701\u00ff\u0001\u0000\u0000\u0000\u0702\u0700\u0001\u0000\u0000"+
		"\u0000\u0703\u0704\u0005T\u0000\u0000\u0704\u0705\u0003\u011a\u008d\u0000"+
		"\u0705\u0707\u0005U\u0000\u0000\u0706\u0708\u0003\u0106\u0083\u0000\u0707"+
		"\u0706\u0001\u0000\u0000\u0000\u0707\u0708\u0001\u0000\u0000\u0000\u0708"+
		"\u070a\u0001\u0000\u0000\u0000\u0709\u070b\u0003\u010a\u0085\u0000\u070a"+
		"\u0709\u0001\u0000\u0000\u0000\u070a\u070b\u0001\u0000\u0000\u0000\u070b"+
		"\u070d\u0001\u0000\u0000\u0000\u070c\u070e\u0003\u0198\u00cc\u0000\u070d"+
		"\u070c\u0001\u0000\u0000\u0000\u070d\u070e\u0001\u0000\u0000\u0000\u070e"+
		"\u0710\u0001\u0000\u0000\u0000\u070f\u0711\u0003\u00e0p\u0000\u0710\u070f"+
		"\u0001\u0000\u0000\u0000\u0710\u0711\u0001\u0000\u0000\u0000\u0711\u0101"+
		"\u0001\u0000\u0000\u0000\u0712\u0713\u0005y\u0000\u0000\u0713\u0715\u0003"+
		"\u00a6S\u0000\u0714\u0716\u0003\u0110\u0088\u0000\u0715\u0714\u0001\u0000"+
		"\u0000\u0000\u0715\u0716\u0001\u0000\u0000\u0000\u0716\u0103\u0001\u0000"+
		"\u0000\u0000\u0717\u0719\u0005\\\u0000\u0000\u0718\u071a\u0003\u00e0p"+
		"\u0000\u0719\u0718\u0001\u0000\u0000\u0000\u0719\u071a\u0001\u0000\u0000"+
		"\u0000\u071a\u071c\u0001\u0000\u0000\u0000\u071b\u071d\u0003\u0106\u0083"+
		"\u0000\u071c\u071b\u0001\u0000\u0000\u0000\u071c\u071d\u0001\u0000\u0000"+
		"\u0000\u071d\u072f\u0001\u0000\u0000\u0000\u071e\u0720\u0005`\u0000\u0000"+
		"\u071f\u0721\u0003\u00e0p\u0000\u0720\u071f\u0001\u0000\u0000\u0000\u0720"+
		"\u0721\u0001\u0000\u0000\u0000\u0721\u072f\u0001\u0000\u0000\u0000\u0722"+
		"\u0724\u0005\u0004\u0000\u0000\u0723\u0725\u0003\u00e0p\u0000\u0724\u0723"+
		"\u0001\u0000\u0000\u0000\u0724\u0725\u0001\u0000\u0000\u0000\u0725\u072f"+
		"\u0001\u0000\u0000\u0000\u0726\u0727\u0003\n\u0005\u0000\u0727\u0729\u0005"+
		"\\\u0000\u0000\u0728\u072a\u0003\u00e0p\u0000\u0729\u0728\u0001\u0000"+
		"\u0000\u0000\u0729\u072a\u0001\u0000\u0000\u0000\u072a\u072c\u0001\u0000"+
		"\u0000\u0000\u072b\u072d\u0003\u0106\u0083\u0000\u072c\u072b\u0001\u0000"+
		"\u0000\u0000\u072c\u072d\u0001\u0000\u0000\u0000\u072d\u072f\u0001\u0000"+
		"\u0000\u0000\u072e\u0717\u0001\u0000\u0000\u0000\u072e\u071e\u0001\u0000"+
		"\u0000\u0000\u072e\u0722\u0001\u0000\u0000\u0000\u072e\u0726\u0001\u0000"+
		"\u0000\u0000\u072f\u0105\u0001\u0000\u0000\u0000\u0730\u0732\u0003\u0108"+
		"\u0084\u0000\u0731\u0733\u0003\u0106\u0083\u0000\u0732\u0731\u0001\u0000"+
		"\u0000\u0000\u0732\u0733\u0001\u0000\u0000\u0000\u0733\u0107\u0001\u0000"+
		"\u0000\u0000\u0734\u0735\u0007\u0005\u0000\u0000\u0735\u0109\u0001\u0000"+
		"\u0000\u0000\u0736\u0737\u0007\u0006\u0000\u0000\u0737\u010b\u0001\u0000"+
		"\u0000\u0000\u0738\u073a\u0005\u0080\u0000\u0000\u0739\u0738\u0001\u0000"+
		"\u0000\u0000\u0739\u073a\u0001\u0000\u0000\u0000\u073a\u073b\u0001\u0000"+
		"\u0000\u0000\u073b\u073c\u0003\u0004\u0002\u0000\u073c\u010d\u0001\u0000"+
		"\u0000\u0000\u073d\u073f\u0003\u00a4R\u0000\u073e\u0740\u0003\u0110\u0088"+
		"\u0000\u073f\u073e\u0001\u0000\u0000\u0000\u073f\u0740\u0001\u0000\u0000"+
		"\u0000\u0740\u010f\u0001\u0000\u0000\u0000\u0741\u074a\u0003\u0112\u0089"+
		"\u0000\u0742\u0744\u0003\u0114\u008a\u0000\u0743\u0742\u0001\u0000\u0000"+
		"\u0000\u0743\u0744\u0001\u0000\u0000\u0000\u0744\u0745\u0001\u0000\u0000"+
		"\u0000\u0745\u0746\u0003\u0100\u0080\u0000\u0746\u0747\u0003\u0102\u0081"+
		"\u0000\u0747\u074a\u0001\u0000\u0000\u0000\u0748\u074a\u0003\u0116\u008b"+
		"\u0000\u0749\u0741\u0001\u0000\u0000\u0000\u0749\u0743\u0001\u0000\u0000"+
		"\u0000\u0749\u0748\u0001\u0000\u0000\u0000\u074a\u0111\u0001\u0000\u0000"+
		"\u0000\u074b\u0751\u0003\u0114\u008a\u0000\u074c\u074e\u0003\u0104\u0082"+
		"\u0000\u074d\u074f\u0003\u0112\u0089\u0000\u074e\u074d\u0001\u0000\u0000"+
		"\u0000\u074e\u074f\u0001\u0000\u0000\u0000\u074f\u0751\u0001\u0000\u0000"+
		"\u0000\u0750\u074b\u0001\u0000\u0000\u0000\u0750\u074c\u0001\u0000\u0000"+
		"\u0000\u0751\u0113\u0001\u0000\u0000\u0000\u0752\u0753\u0006\u008a\uffff"+
		"\uffff\u0000\u0753\u0761\u0003\u0100\u0080\u0000\u0754\u0756\u0005V\u0000"+
		"\u0000\u0755\u0757\u0003h4\u0000\u0756\u0755\u0001\u0000\u0000\u0000\u0756"+
		"\u0757\u0001\u0000\u0000\u0000\u0757\u0758\u0001\u0000\u0000\u0000\u0758"+
		"\u075a\u0005W\u0000\u0000\u0759\u075b\u0003\u00e0p\u0000\u075a\u0759\u0001"+
		"\u0000\u0000\u0000\u075a\u075b\u0001\u0000\u0000\u0000\u075b\u0761\u0001"+
		"\u0000\u0000\u0000\u075c\u075d\u0005T\u0000\u0000\u075d\u075e\u0003\u0112"+
		"\u0089\u0000\u075e\u075f\u0005U\u0000\u0000\u075f\u0761\u0001\u0000\u0000"+
		"\u0000\u0760\u0752\u0001\u0000\u0000\u0000\u0760\u0754\u0001\u0000\u0000"+
		"\u0000\u0760\u075c\u0001\u0000\u0000\u0000\u0761\u076f\u0001\u0000\u0000"+
		"\u0000\u0762\u0763\n\u0005\u0000\u0000\u0763\u076e\u0003\u0100\u0080\u0000"+
		"\u0764\u0765\n\u0003\u0000\u0000\u0765\u0767\u0005V\u0000\u0000\u0766"+
		"\u0768\u0003h4\u0000\u0767\u0766\u0001\u0000\u0000\u0000\u0767\u0768\u0001"+
		"\u0000\u0000\u0000\u0768\u0769\u0001\u0000\u0000\u0000\u0769\u076b\u0005"+
		"W\u0000\u0000\u076a\u076c\u0003\u00e0p\u0000\u076b\u076a\u0001\u0000\u0000"+
		"\u0000\u076b\u076c\u0001\u0000\u0000\u0000\u076c\u076e\u0001\u0000\u0000"+
		"\u0000\u076d\u0762\u0001\u0000\u0000\u0000\u076d\u0764\u0001\u0000\u0000"+
		"\u0000\u076e\u0771\u0001\u0000\u0000\u0000\u076f\u076d\u0001\u0000\u0000"+
		"\u0000\u076f\u0770\u0001\u0000\u0000\u0000\u0770\u0115\u0001\u0000\u0000"+
		"\u0000\u0771\u076f\u0001\u0000\u0000\u0000\u0772\u0777\u0003\u0118\u008c"+
		"\u0000\u0773\u0774\u0003\u0104\u0082\u0000\u0774\u0775\u0003\u0116\u008b"+
		"\u0000\u0775\u0777\u0001\u0000\u0000\u0000\u0776\u0772\u0001\u0000\u0000"+
		"\u0000\u0776\u0773\u0001\u0000\u0000\u0000\u0777\u0117\u0001\u0000\u0000"+
		"\u0000\u0778\u0779\u0006\u008c\uffff\uffff\u0000\u0779\u077a\u0005\u0080"+
		"\u0000\u0000\u077a\u0788\u0001\u0000\u0000\u0000\u077b\u077c\n\u0003\u0000"+
		"\u0000\u077c\u0787\u0003\u0100\u0080\u0000\u077d\u077e\n\u0002\u0000\u0000"+
		"\u077e\u0780\u0005V\u0000\u0000\u077f\u0781\u0003h4\u0000\u0780\u077f"+
		"\u0001\u0000\u0000\u0000\u0780\u0781\u0001\u0000\u0000\u0000\u0781\u0782"+
		"\u0001\u0000\u0000\u0000\u0782\u0784\u0005W\u0000\u0000\u0783\u0785\u0003"+
		"\u00e0p\u0000\u0784\u0783\u0001\u0000\u0000\u0000\u0784\u0785\u0001\u0000"+
		"\u0000\u0000\u0785\u0787\u0001\u0000\u0000\u0000\u0786\u077b\u0001\u0000"+
		"\u0000\u0000\u0786\u077d\u0001\u0000\u0000\u0000\u0787\u078a\u0001\u0000"+
		"\u0000\u0000\u0788\u0786\u0001\u0000\u0000\u0000\u0788\u0789\u0001\u0000"+
		"\u0000\u0000\u0789\u0119\u0001\u0000\u0000\u0000\u078a\u0788\u0001\u0000"+
		"\u0000\u0000\u078b\u078d\u0003\u011c\u008e\u0000\u078c\u078b\u0001\u0000"+
		"\u0000\u0000\u078c\u078d\u0001\u0000\u0000\u0000\u078d\u078f\u0001\u0000"+
		"\u0000\u0000\u078e\u0790\u0005\u0080\u0000\u0000\u078f\u078e\u0001\u0000"+
		"\u0000\u0000\u078f\u0790\u0001\u0000\u0000\u0000\u0790\u0796\u0001\u0000"+
		"\u0000\u0000\u0791\u0792\u0003\u011c\u008e\u0000\u0792\u0793\u0005w\u0000"+
		"\u0000\u0793\u0794\u0005\u0080\u0000\u0000\u0794\u0796\u0001\u0000\u0000"+
		"\u0000\u0795\u078c\u0001\u0000\u0000\u0000\u0795\u0791\u0001\u0000\u0000"+
		"\u0000\u0796\u011b\u0001\u0000\u0000\u0000\u0797\u0798\u0006\u008e\uffff"+
		"\uffff\u0000\u0798\u0799\u0003\u011e\u008f\u0000\u0799\u079f\u0001\u0000"+
		"\u0000\u0000\u079a\u079b\n\u0001\u0000\u0000\u079b\u079c\u0005w\u0000"+
		"\u0000\u079c\u079e\u0003\u011e\u008f\u0000\u079d\u079a\u0001\u0000\u0000"+
		"\u0000\u079e\u07a1\u0001\u0000\u0000\u0000\u079f\u079d\u0001\u0000\u0000"+
		"\u0000\u079f\u07a0\u0001\u0000\u0000\u0000\u07a0\u011d\u0001\u0000\u0000"+
		"\u0000\u07a1\u079f\u0001\u0000\u0000\u0000\u07a2\u07a4\u0003\u00e0p\u0000"+
		"\u07a3\u07a2\u0001\u0000\u0000\u0000\u07a3\u07a4\u0001\u0000\u0000\u0000"+
		"\u07a4\u07a6\u0001\u0000\u0000\u0000\u07a5\u07a7\u0003\u0106\u0083\u0000"+
		"\u07a6\u07a5\u0001\u0000\u0000\u0000\u07a6\u07a7\u0001\u0000\u0000\u0000"+
		"\u07a7\u07a8\u0001\u0000\u0000\u0000\u07a8\u07a9\u0003\u0096K\u0000\u07a9"+
		"\u07aa\u0003\u00fa}\u0000\u07aa\u07c5\u0001\u0000\u0000\u0000\u07ab\u07ad"+
		"\u0003\u00e0p\u0000\u07ac\u07ab\u0001\u0000\u0000\u0000\u07ac\u07ad\u0001"+
		"\u0000\u0000\u0000\u07ad\u07ae\u0001\u0000\u0000\u0000\u07ae\u07af\u0003"+
		"\u0096K\u0000\u07af\u07b0\u0003\u00fa}\u0000\u07b0\u07b1\u0005d\u0000"+
		"\u0000\u07b1\u07b2\u0003\u0128\u0094\u0000\u07b2\u07c5\u0001\u0000\u0000"+
		"\u0000\u07b3\u07b5\u0003\u00e0p\u0000\u07b4\u07b3\u0001\u0000\u0000\u0000"+
		"\u07b4\u07b5\u0001\u0000\u0000\u0000\u07b5\u07b6\u0001\u0000\u0000\u0000"+
		"\u07b6\u07b8\u0003\u0096K\u0000\u07b7\u07b9\u0003\u0110\u0088\u0000\u07b8"+
		"\u07b7\u0001\u0000\u0000\u0000\u07b8\u07b9\u0001\u0000\u0000\u0000\u07b9"+
		"\u07c5\u0001\u0000\u0000\u0000\u07ba\u07bc\u0003\u00e0p\u0000\u07bb\u07ba"+
		"\u0001\u0000\u0000\u0000\u07bb\u07bc\u0001\u0000\u0000\u0000\u07bc\u07bd"+
		"\u0001\u0000\u0000\u0000\u07bd\u07bf\u0003\u0096K\u0000\u07be\u07c0\u0003"+
		"\u0110\u0088\u0000\u07bf\u07be\u0001\u0000\u0000\u0000\u07bf\u07c0\u0001"+
		"\u0000\u0000\u0000\u07c0\u07c1\u0001\u0000\u0000\u0000\u07c1\u07c2\u0005"+
		"d\u0000\u0000\u07c2\u07c3\u0003\u0128\u0094\u0000\u07c3\u07c5\u0001\u0000"+
		"\u0000\u0000\u07c4\u07a3\u0001\u0000\u0000\u0000\u07c4\u07ac\u0001\u0000"+
		"\u0000\u0000\u07c4\u07b4\u0001\u0000\u0000\u0000\u07c4\u07bb\u0001\u0000"+
		"\u0000\u0000\u07c5\u011f\u0001\u0000\u0000\u0000\u07c6\u07c8\u0003\u00e0"+
		"p\u0000\u07c7\u07c6\u0001\u0000\u0000\u0000\u07c7\u07c8\u0001\u0000\u0000"+
		"\u0000\u07c8\u07ca\u0001\u0000\u0000\u0000\u07c9\u07cb\u0003\u0096K\u0000"+
		"\u07ca\u07c9\u0001\u0000\u0000\u0000\u07ca\u07cb\u0001\u0000\u0000\u0000"+
		"\u07cb\u07cc\u0001\u0000\u0000\u0000\u07cc\u07ce\u0003\u00fa}\u0000\u07cd"+
		"\u07cf\u0003\u0150\u00a8\u0000\u07ce\u07cd\u0001\u0000\u0000\u0000\u07ce"+
		"\u07cf\u0001\u0000\u0000\u0000\u07cf\u07d0\u0001\u0000\u0000\u0000\u07d0"+
		"\u07d1\u0003\u0122\u0091\u0000\u07d1\u0121\u0001\u0000\u0000\u0000\u07d2"+
		"\u07d4\u0003\u0168\u00b4\u0000\u07d3\u07d2\u0001\u0000\u0000\u0000\u07d3"+
		"\u07d4\u0001\u0000\u0000\u0000\u07d4\u07d5\u0001\u0000\u0000\u0000\u07d5"+
		"\u07de\u0003p8\u0000\u07d6\u07de\u0003\u018e\u00c7\u0000\u07d7\u07d8\u0005"+
		"d\u0000\u0000\u07d8\u07d9\u0005\u0019\u0000\u0000\u07d9\u07de\u0005}\u0000"+
		"\u0000\u07da\u07db\u0005d\u0000\u0000\u07db\u07dc\u0005\u001a\u0000\u0000"+
		"\u07dc\u07de\u0005}\u0000\u0000\u07dd\u07d3\u0001\u0000\u0000\u0000\u07dd"+
		"\u07d6\u0001\u0000\u0000\u0000\u07dd\u07d7\u0001\u0000\u0000\u0000\u07dd"+
		"\u07da\u0001\u0000\u0000\u0000\u07de\u0123\u0001\u0000\u0000\u0000\u07df"+
		"\u07e5\u0003\u0126\u0093\u0000\u07e0\u07e1\u0005T\u0000\u0000\u07e1\u07e2"+
		"\u0003$\u0012\u0000\u07e2\u07e3\u0005U\u0000\u0000\u07e3\u07e5\u0001\u0000"+
		"\u0000\u0000\u07e4\u07df\u0001\u0000\u0000\u0000\u07e4\u07e0\u0001\u0000"+
		"\u0000\u0000\u07e5\u0125\u0001\u0000\u0000\u0000\u07e6\u07e7\u0005d\u0000"+
		"\u0000\u07e7\u07ea\u0003\u0128\u0094\u0000\u07e8\u07ea\u0003\u012c\u0096"+
		"\u0000\u07e9\u07e6\u0001\u0000\u0000\u0000\u07e9\u07e8\u0001\u0000\u0000"+
		"\u0000\u07ea\u0127\u0001\u0000\u0000\u0000\u07eb\u07ee\u0003b1\u0000\u07ec"+
		"\u07ee\u0003\u012c\u0096\u0000\u07ed\u07eb\u0001\u0000\u0000\u0000\u07ed"+
		"\u07ec\u0001\u0000\u0000\u0000\u07ee\u0129\u0001\u0000\u0000\u0000\u07ef"+
		"\u07f0\u0006\u0095\uffff\uffff\u0000\u07f0\u07f2\u0003\u0128\u0094\u0000"+
		"\u07f1\u07f3\u0005\u0080\u0000\u0000\u07f2\u07f1\u0001\u0000\u0000\u0000"+
		"\u07f2\u07f3\u0001\u0000\u0000\u0000\u07f3\u07fc\u0001\u0000\u0000\u0000"+
		"\u07f4\u07f5\n\u0001\u0000\u0000\u07f5\u07f6\u0005w\u0000\u0000\u07f6"+
		"\u07f8\u0003\u0128\u0094\u0000\u07f7\u07f9\u0005\u0080\u0000\u0000\u07f8"+
		"\u07f7\u0001\u0000\u0000\u0000\u07f8\u07f9\u0001\u0000\u0000\u0000\u07f9"+
		"\u07fb\u0001\u0000\u0000\u0000\u07fa\u07f4\u0001\u0000\u0000\u0000\u07fb"+
		"\u07fe\u0001\u0000\u0000\u0000\u07fc\u07fa\u0001\u0000\u0000\u0000\u07fc"+
		"\u07fd\u0001\u0000\u0000\u0000\u07fd\u012b\u0001\u0000\u0000\u0000\u07fe"+
		"\u07fc\u0001\u0000\u0000\u0000\u07ff\u0800\u0005X\u0000\u0000\u0800\u0802"+
		"\u0003\u012a\u0095\u0000\u0801\u0803\u0005w\u0000\u0000\u0802\u0801\u0001"+
		"\u0000\u0000\u0000\u0802\u0803\u0001\u0000\u0000\u0000\u0803\u0804\u0001"+
		"\u0000\u0000\u0000\u0804\u0805\u0005Y\u0000\u0000\u0805\u0809\u0001\u0000"+
		"\u0000\u0000\u0806\u0807\u0005X\u0000\u0000\u0807\u0809\u0005Y\u0000\u0000"+
		"\u0808\u07ff\u0001\u0000\u0000\u0000\u0808\u0806\u0001\u0000\u0000\u0000"+
		"\u0809\u012d\u0001\u0000\u0000\u0000\u080a\u080d\u0005\u0081\u0000\u0000"+
		"\u080b\u080d\u0003\u017c\u00be\u0000\u080c\u080a\u0001\u0000\u0000\u0000"+
		"\u080c\u080b\u0001\u0000\u0000\u0000\u080d\u012f\u0001\u0000\u0000\u0000"+
		"\u080e\u080f\u0003\u0132\u0099\u0000\u080f\u0811\u0005X\u0000\u0000\u0810"+
		"\u0812\u0003\u0148\u00a4\u0000\u0811\u0810\u0001\u0000\u0000\u0000\u0811"+
		"\u0812\u0001\u0000\u0000\u0000\u0812\u0813\u0001\u0000\u0000\u0000\u0813"+
		"\u0815\u0005Y\u0000\u0000\u0814\u0816\u0003\u009cN\u0000\u0815\u0814\u0001"+
		"\u0000\u0000\u0000\u0815\u0816\u0001\u0000\u0000\u0000\u0816\u0131\u0001"+
		"\u0000\u0000\u0000\u0817\u0819\u0003\u0146\u00a3\u0000\u0818\u081a\u0003"+
		"\u009eO\u0000\u0819\u0818\u0001\u0000\u0000\u0000\u0819\u081a\u0001\u0000"+
		"\u0000\u0000\u081a\u0133\u0001\u0000\u0000\u0000\u081b\u081c\u0003\u0136"+
		"\u009b\u0000\u081c\u081e\u0005X\u0000\u0000\u081d\u081f\u0003\u0148\u00a4"+
		"\u0000\u081e\u081d\u0001\u0000\u0000\u0000\u081e\u081f\u0001\u0000\u0000"+
		"\u0000\u081f\u0820\u0001\u0000\u0000\u0000\u0820\u0822\u0005Y\u0000\u0000"+
		"\u0821\u0823\u0003\u009cN\u0000\u0822\u0821\u0001\u0000\u0000\u0000\u0822"+
		"\u0823\u0001\u0000\u0000\u0000\u0823\u0135\u0001\u0000\u0000\u0000\u0824"+
		"\u0826\u0003\u0146\u00a3\u0000\u0825\u0827\u0003\u009eO\u0000\u0826\u0825"+
		"\u0001\u0000\u0000\u0000\u0826\u0827\u0001\u0000\u0000\u0000\u0827\u0828"+
		"\u0001\u0000\u0000\u0000\u0828\u0829\u0003\u0156\u00ab\u0000\u0829\u0137"+
		"\u0001\u0000\u0000\u0000\u082a\u082b\u0003\u013e\u009f\u0000\u082b\u082d"+
		"\u0005X\u0000\u0000\u082c\u082e\u0003\u0148\u00a4\u0000\u082d\u082c\u0001"+
		"\u0000\u0000\u0000\u082d\u082e\u0001\u0000\u0000\u0000\u082e\u082f\u0001"+
		"\u0000\u0000\u0000\u082f\u0830\u0005Y\u0000\u0000\u0830\u0139\u0001\u0000"+
		"\u0000\u0000\u0831\u0832\u0003\u013c\u009e\u0000\u0832\u0834\u0005X\u0000"+
		"\u0000\u0833\u0835\u0003\u0148\u00a4\u0000\u0834\u0833\u0001\u0000\u0000"+
		"\u0000\u0834\u0835\u0001\u0000\u0000\u0000\u0835\u0836\u0001\u0000\u0000"+
		"\u0000\u0836\u0837\u0005Y\u0000\u0000\u0837\u013b\u0001\u0000\u0000\u0000"+
		"\u0838\u083a\u0003\u0144\u00a2\u0000\u0839\u083b\u0003\u00e0p\u0000\u083a"+
		"\u0839\u0001\u0000\u0000\u0000\u083a\u083b\u0001\u0000\u0000\u0000\u083b"+
		"\u083c\u0001\u0000\u0000\u0000\u083c\u083e\u0003\u0140\u00a0\u0000\u083d"+
		"\u083f\u0003\u0142\u00a1\u0000\u083e\u083d\u0001\u0000\u0000\u0000\u083e"+
		"\u083f\u0001\u0000\u0000\u0000\u083f\u0845\u0001\u0000\u0000\u0000\u0840"+
		"\u0842\u0003\u0144\u00a2\u0000\u0841\u0843\u0003\u00e0p\u0000\u0842\u0841"+
		"\u0001\u0000\u0000\u0000\u0842\u0843\u0001\u0000\u0000\u0000\u0843\u0845"+
		"\u0001\u0000\u0000\u0000\u0844\u0838\u0001\u0000\u0000\u0000\u0844\u0840"+
		"\u0001\u0000\u0000\u0000\u0845\u013d\u0001\u0000\u0000\u0000\u0846\u0848"+
		"\u0003\u0144\u00a2\u0000\u0847\u0849\u0003\u00e0p\u0000\u0848\u0847\u0001"+
		"\u0000\u0000\u0000\u0848\u0849\u0001\u0000\u0000\u0000\u0849\u084a\u0001"+
		"\u0000\u0000\u0000\u084a\u084c\u0003\u0140\u00a0\u0000\u084b\u084d\u0003"+
		"\u0142\u00a1\u0000\u084c\u084b\u0001\u0000\u0000\u0000\u084c\u084d\u0001"+
		"\u0000\u0000\u0000\u084d\u084e\u0001\u0000\u0000\u0000\u084e\u084f\u0003"+
		"\u0156\u00ab\u0000\u084f\u0857\u0001\u0000\u0000\u0000\u0850\u0852\u0003"+
		"\u0144\u00a2\u0000\u0851\u0853\u0003\u00e0p\u0000\u0852\u0851\u0001\u0000"+
		"\u0000\u0000\u0852\u0853\u0001\u0000\u0000\u0000\u0853\u0854\u0001\u0000"+
		"\u0000\u0000\u0854\u0855\u0003\u0156\u00ab\u0000\u0855\u0857\u0001\u0000"+
		"\u0000\u0000\u0856\u0846\u0001\u0000\u0000\u0000\u0856\u0850\u0001\u0000"+
		"\u0000\u0000\u0857\u013f\u0001\u0000\u0000\u0000\u0858\u085a\u0003\n\u0005"+
		"\u0000\u0859\u0858\u0001\u0000\u0000\u0000\u0859\u085a\u0001\u0000\u0000"+
		"\u0000\u085a\u085b\u0001\u0000\u0000\u0000\u085b\u085c\u0003\u012e\u0097"+
		"\u0000\u085c\u0141\u0001\u0000\u0000\u0000\u085d\u085e\u0005$\u0000\u0000"+
		"\u085e\u0143\u0001\u0000\u0000\u0000\u085f\u0860\u0005\u0013\u0000\u0000"+
		"\u0860\u0145\u0001\u0000\u0000\u0000\u0861\u0863\u0005H\u0000\u0000\u0862"+
		"\u0861\u0001\u0000\u0000\u0000\u0862\u0863\u0001\u0000\u0000\u0000\u0863"+
		"\u0864\u0001\u0000\u0000\u0000\u0864\u0865\u0005@\u0000\u0000\u0865\u0147"+
		"\u0001\u0000\u0000\u0000\u0866\u0868\u0003\u014a\u00a5\u0000\u0867\u0869"+
		"\u0003\u0148\u00a4\u0000\u0868\u0867\u0001\u0000\u0000\u0000\u0868\u0869"+
		"\u0001\u0000\u0000\u0000\u0869\u0870\u0001\u0000\u0000\u0000\u086a\u086b"+
		"\u0003\u0160\u00b0\u0000\u086b\u086d\u0005{\u0000\u0000\u086c\u086e\u0003"+
		"\u0148\u00a4\u0000\u086d\u086c\u0001\u0000\u0000\u0000\u086d\u086e\u0001"+
		"\u0000\u0000\u0000\u086e\u0870\u0001\u0000\u0000\u0000\u086f\u0866\u0001"+
		"\u0000\u0000\u0000\u086f\u086a\u0001\u0000\u0000\u0000\u0870\u0149\u0001"+
		"\u0000\u0000\u0000\u0871\u0873\u0003\u00e0p\u0000\u0872\u0871\u0001\u0000"+
		"\u0000\u0000\u0872\u0873\u0001\u0000\u0000\u0000\u0873\u0875\u0001\u0000"+
		"\u0000\u0000\u0874\u0876\u0003\u0096K\u0000\u0875\u0874\u0001\u0000\u0000"+
		"\u0000\u0875\u0876\u0001\u0000\u0000\u0000\u0876\u0878\u0001\u0000\u0000"+
		"\u0000\u0877\u0879\u0003H$\u0000\u0878\u0877\u0001\u0000\u0000\u0000\u0878"+
		"\u0879\u0001\u0000\u0000\u0000\u0879\u087b\u0001\u0000\u0000\u0000\u087a"+
		"\u087c\u0003\u014c\u00a6\u0000\u087b\u087a\u0001\u0000\u0000\u0000\u087b"+
		"\u087c\u0001\u0000\u0000\u0000\u087c\u087d\u0001\u0000\u0000\u0000\u087d"+
		"\u0885\u0005}\u0000\u0000\u087e\u0885\u0003\u0120\u0090\u0000\u087f\u0885"+
		"\u0003\u00d8l\u0000\u0880\u0885\u0003\u008eG\u0000\u0881\u0885\u0003\u0174"+
		"\u00ba\u0000\u0882\u0885\u0003\u008aE\u0000\u0883\u0885\u0003\u0090H\u0000"+
		"\u0884\u0872\u0001\u0000\u0000\u0000\u0884\u087e\u0001\u0000\u0000\u0000"+
		"\u0884\u087f\u0001\u0000\u0000\u0000\u0884\u0880\u0001\u0000\u0000\u0000"+
		"\u0884\u0881\u0001\u0000\u0000\u0000\u0884\u0882\u0001\u0000\u0000\u0000"+
		"\u0884\u0883\u0001\u0000\u0000\u0000\u0885\u014b\u0001\u0000\u0000\u0000"+
		"\u0886\u0887\u0006\u00a6\uffff\uffff\u0000\u0887\u0888\u0003\u014e\u00a7"+
		"\u0000\u0888\u088e\u0001\u0000\u0000\u0000\u0889\u088a\n\u0001\u0000\u0000"+
		"\u088a\u088b\u0005w\u0000\u0000\u088b\u088d\u0003\u014e\u00a7\u0000\u088c"+
		"\u0889\u0001\u0000\u0000\u0000\u088d\u0890\u0001\u0000\u0000\u0000\u088e"+
		"\u088c\u0001\u0000\u0000\u0000\u088e\u088f\u0001\u0000\u0000\u0000\u088f"+
		"\u014d\u0001\u0000\u0000\u0000\u0890\u088e\u0001\u0000\u0000\u0000\u0891"+
		"\u0893\u0003\u00fa}\u0000\u0892\u0894\u0003\u0150\u00a8\u0000\u0893\u0892"+
		"\u0001\u0000\u0000\u0000\u0893\u0894\u0001\u0000\u0000\u0000\u0894\u0896"+
		"\u0001\u0000\u0000\u0000\u0895\u0897\u0003\u0154\u00aa\u0000\u0896\u0895"+
		"\u0001\u0000\u0000\u0000\u0896\u0897\u0001\u0000\u0000\u0000\u0897\u08a5"+
		"\u0001\u0000\u0000\u0000\u0898\u089a\u0003\u00fa}\u0000\u0899\u089b\u0003"+
		"\u0126\u0093\u0000\u089a\u0899\u0001\u0000\u0000\u0000\u089a\u089b\u0001"+
		"\u0000\u0000\u0000\u089b\u08a5\u0001\u0000\u0000\u0000\u089c\u089e\u0005"+
		"\u0081\u0000\u0000\u089d\u089c\u0001\u0000\u0000\u0000\u089d\u089e\u0001"+
		"\u0000\u0000\u0000\u089e\u08a0\u0001\u0000\u0000\u0000\u089f\u08a1\u0003"+
		"\u00e0p\u0000\u08a0\u089f\u0001\u0000\u0000\u0000\u08a0\u08a1\u0001\u0000"+
		"\u0000\u0000\u08a1\u08a2\u0001\u0000\u0000\u0000\u08a2\u08a3\u0005{\u0000"+
		"\u0000\u08a3\u08a5\u0003h4\u0000\u08a4\u0891\u0001\u0000\u0000\u0000\u08a4"+
		"\u0898\u0001\u0000\u0000\u0000\u08a4\u089d\u0001\u0000\u0000\u0000\u08a5"+
		"\u014f\u0001\u0000\u0000\u0000\u08a6\u08a7\u0006\u00a8\uffff\uffff\u0000"+
		"\u08a7\u08a8\u0003\u0152\u00a9\u0000\u08a8\u08ad\u0001\u0000\u0000\u0000"+
		"\u08a9\u08aa\n\u0001\u0000\u0000\u08aa\u08ac\u0003\u0152\u00a9\u0000\u08ab"+
		"\u08a9\u0001\u0000\u0000\u0000\u08ac\u08af\u0001\u0000\u0000\u0000\u08ad"+
		"\u08ab\u0001\u0000\u0000\u0000\u08ad\u08ae\u0001\u0000\u0000\u0000\u08ae"+
		"\u0151\u0001\u0000\u0000\u0000\u08af\u08ad\u0001\u0000\u0000\u0000\u08b0"+
		"\u08b1\u0007\u0007\u0000\u0000\u08b1\u0153\u0001\u0000\u0000\u0000\u08b2"+
		"\u08b3\u0005d\u0000\u0000\u08b3\u08b4\u0005\u0084\u0000\u0000\u08b4\u08b5"+
		"\u0006\u00aa\uffff\uffff\u0000\u08b5\u0155\u0001\u0000\u0000\u0000\u08b6"+
		"\u08b7\u0005{\u0000\u0000\u08b7\u08b8\u0003\u0158\u00ac\u0000\u08b8\u0157"+
		"\u0001\u0000\u0000\u0000\u08b9\u08ba\u0006\u00ac\uffff\uffff\u0000\u08ba"+
		"\u08bc\u0003\u015a\u00ad\u0000\u08bb\u08bd\u0005\u0080\u0000\u0000\u08bc"+
		"\u08bb\u0001\u0000\u0000\u0000\u08bc\u08bd\u0001\u0000\u0000\u0000\u08bd"+
		"\u08c6\u0001\u0000\u0000\u0000\u08be\u08bf\n\u0001\u0000\u0000\u08bf\u08c0"+
		"\u0005w\u0000\u0000\u08c0\u08c2\u0003\u015a\u00ad\u0000\u08c1\u08c3\u0005"+
		"\u0080\u0000\u0000\u08c2\u08c1\u0001\u0000\u0000\u0000\u08c2\u08c3\u0001"+
		"\u0000\u0000\u0000\u08c3\u08c5\u0001\u0000\u0000\u0000\u08c4\u08be\u0001"+
		"\u0000\u0000\u0000\u08c5\u08c8\u0001\u0000\u0000\u0000\u08c6\u08c4\u0001"+
		"\u0000\u0000\u0000\u08c6\u08c7\u0001\u0000\u0000\u0000\u08c7\u0159\u0001"+
		"\u0000\u0000\u0000\u08c8\u08c6\u0001\u0000\u0000\u0000\u08c9\u08cb\u0003"+
		"\u00e0p\u0000\u08ca\u08c9\u0001\u0000\u0000\u0000\u08ca\u08cb\u0001\u0000"+
		"\u0000\u0000\u08cb\u08cc\u0001\u0000\u0000\u0000\u08cc\u08df\u0003\u015e"+
		"\u00af\u0000\u08cd\u08cf\u0003\u00e0p\u0000\u08ce\u08cd\u0001\u0000\u0000"+
		"\u0000\u08ce\u08cf\u0001\u0000\u0000\u0000\u08cf\u08d0\u0001\u0000\u0000"+
		"\u0000\u08d0\u08d2\u0005N\u0000\u0000\u08d1\u08d3\u0003\u0160\u00b0\u0000"+
		"\u08d2\u08d1\u0001\u0000\u0000\u0000\u08d2\u08d3\u0001\u0000\u0000\u0000"+
		"\u08d3\u08d4\u0001\u0000\u0000\u0000\u08d4\u08df\u0003\u015e\u00af\u0000"+
		"\u08d5\u08d7\u0003\u00e0p\u0000\u08d6\u08d5\u0001\u0000\u0000\u0000\u08d6"+
		"\u08d7\u0001\u0000\u0000\u0000\u08d7\u08d8\u0001\u0000\u0000\u0000\u08d8"+
		"\u08da\u0003\u0160\u00b0\u0000\u08d9\u08db\u0005N\u0000\u0000\u08da\u08d9"+
		"\u0001\u0000\u0000\u0000\u08da\u08db\u0001\u0000\u0000\u0000\u08db\u08dc"+
		"\u0001\u0000\u0000\u0000\u08dc\u08dd\u0003\u015e\u00af\u0000\u08dd\u08df"+
		"\u0001\u0000\u0000\u0000\u08de\u08ca\u0001\u0000\u0000\u0000\u08de\u08ce"+
		"\u0001\u0000\u0000\u0000\u08de\u08d6\u0001\u0000\u0000\u0000\u08df\u015b"+
		"\u0001\u0000\u0000\u0000\u08e0\u08e2\u0003\n\u0005\u0000\u08e1\u08e0\u0001"+
		"\u0000\u0000\u0000\u08e1\u08e2\u0001\u0000\u0000\u0000\u08e2\u08e3\u0001"+
		"\u0000\u0000\u0000\u08e3\u08e6\u0003\u012e\u0097\u0000\u08e4\u08e6\u0003"+
		"\u00acV\u0000\u08e5\u08e1\u0001\u0000\u0000\u0000\u08e5\u08e4\u0001\u0000"+
		"\u0000\u0000\u08e6\u015d\u0001\u0000\u0000\u0000\u08e7\u08e8\u0003\u015c"+
		"\u00ae\u0000\u08e8\u015f\u0001\u0000\u0000\u0000\u08e9\u08ea\u0007\b\u0000"+
		"\u0000\u08ea\u0161\u0001\u0000\u0000\u0000\u08eb\u08ec\u00052\u0000\u0000"+
		"\u08ec\u08ed\u0003\u0164\u00b2\u0000\u08ed\u0163\u0001\u0000\u0000\u0000"+
		"\u08ee\u08f0\u0003\u00a4R\u0000\u08ef\u08f1\u0003\u0166\u00b3\u0000\u08f0"+
		"\u08ef\u0001\u0000\u0000\u0000\u08f0\u08f1\u0001\u0000\u0000\u0000\u08f1"+
		"\u0165\u0001\u0000\u0000\u0000\u08f2\u08f4\u0003\u0104\u0082\u0000\u08f3"+
		"\u08f5\u0003\u0166\u00b3\u0000\u08f4\u08f3\u0001\u0000\u0000\u0000\u08f4"+
		"\u08f5\u0001\u0000\u0000\u0000\u08f5\u0167\u0001\u0000\u0000\u0000\u08f6"+
		"\u08f7\u0005{\u0000\u0000\u08f7\u08f8\u0003\u016a\u00b5\u0000\u08f8\u0169"+
		"\u0001\u0000\u0000\u0000\u08f9\u08fb\u0003\u016c\u00b6\u0000\u08fa\u08fc"+
		"\u0005\u0080\u0000\u0000\u08fb\u08fa\u0001\u0000\u0000\u0000\u08fb\u08fc"+
		"\u0001\u0000\u0000\u0000\u08fc\u0905\u0001\u0000\u0000\u0000\u08fd\u08ff"+
		"\u0003\u016c\u00b6\u0000\u08fe\u0900\u0005\u0080\u0000\u0000\u08ff\u08fe"+
		"\u0001\u0000\u0000\u0000\u08ff\u0900\u0001\u0000\u0000\u0000\u0900\u0901"+
		"\u0001\u0000\u0000\u0000\u0901\u0902\u0005w\u0000\u0000\u0902\u0903\u0003"+
		"\u016a\u00b5\u0000\u0903\u0905\u0001\u0000\u0000\u0000\u0904\u08f9\u0001"+
		"\u0000\u0000\u0000\u0904\u08fd\u0001\u0000\u0000\u0000\u0905\u016b\u0001"+
		"\u0000\u0000\u0000\u0906\u0907\u0003\u016e\u00b7\u0000\u0907\u0909\u0005"+
		"T\u0000\u0000\u0908\u090a\u0003$\u0012\u0000\u0909\u0908\u0001\u0000\u0000"+
		"\u0000\u0909\u090a\u0001\u0000\u0000\u0000\u090a\u090b\u0001\u0000\u0000"+
		"\u0000\u090b\u090c\u0005U\u0000\u0000\u090c\u0911\u0001\u0000\u0000\u0000"+
		"\u090d\u090e\u0003\u016e\u00b7\u0000\u090e\u090f\u0003\u012c\u0096\u0000"+
		"\u090f\u0911\u0001\u0000\u0000\u0000\u0910\u0906\u0001\u0000\u0000\u0000"+
		"\u0910\u090d\u0001\u0000\u0000\u0000\u0911\u016d\u0001\u0000\u0000\u0000"+
		"\u0912\u0915\u0003\u015c\u00ae\u0000\u0913\u0915\u0005\u0081\u0000\u0000"+
		"\u0914\u0912\u0001\u0000\u0000\u0000\u0914\u0913\u0001\u0000\u0000\u0000"+
		"\u0915\u016f\u0001\u0000\u0000\u0000\u0916\u0917\u00052\u0000\u0000\u0917"+
		"\u0918\u0003\u01a8\u00d4\u0000\u0918\u0171\u0001\u0000\u0000\u0000\u0919"+
		"\u091a\u00052\u0000\u0000\u091a\u091b\u0005\u008a\u0000\u0000\u091b\u091f"+
		"\u0005\u0081\u0000\u0000\u091c\u091d\u00052\u0000\u0000\u091d\u091f\u0005"+
		"\u008d\u0000\u0000\u091e\u0919\u0001\u0000\u0000\u0000\u091e\u091c\u0001"+
		"\u0000\u0000\u0000\u091f\u0173\u0001\u0000\u0000\u0000\u0920\u0921\u0005"+
		"B\u0000\u0000\u0921\u0922\u0005e\u0000\u0000\u0922\u0923\u0003\u0176\u00bb"+
		"\u0000\u0923\u0924\u0005f\u0000\u0000\u0924\u0925\u0003\u0086C\u0000\u0925"+
		"\u0175\u0001\u0000\u0000\u0000\u0926\u0927\u0006\u00bb\uffff\uffff\u0000"+
		"\u0927\u0928\u0003\u0178\u00bc\u0000\u0928\u092e\u0001\u0000\u0000\u0000"+
		"\u0929\u092a\n\u0001\u0000\u0000\u092a\u092b\u0005w\u0000\u0000\u092b"+
		"\u092d\u0003\u0178\u00bc\u0000\u092c\u0929\u0001\u0000\u0000\u0000\u092d"+
		"\u0930\u0001\u0000\u0000\u0000\u092e\u092c\u0001\u0000\u0000\u0000\u092e"+
		"\u092f\u0001\u0000\u0000\u0000\u092f\u0177\u0001\u0000\u0000\u0000\u0930"+
		"\u092e\u0001\u0000\u0000\u0000\u0931\u0934\u0003\u017a\u00bd\u0000\u0932"+
		"\u0934\u0003\u011e\u008f\u0000\u0933\u0931\u0001\u0000\u0000\u0000\u0933"+
		"\u0932\u0001\u0000\u0000\u0000\u0934\u0179\u0001\u0000\u0000\u0000\u0935"+
		"\u0937\u0005\u0013\u0000\u0000\u0936\u0938\u0005\u0080\u0000\u0000\u0937"+
		"\u0936\u0001\u0000\u0000\u0000\u0937\u0938\u0001\u0000\u0000\u0000\u0938"+
		"\u093a\u0001\u0000\u0000\u0000\u0939\u093b\u0005\u0081\u0000\u0000\u093a"+
		"\u0939\u0001\u0000\u0000\u0000\u093a\u093b\u0001\u0000\u0000\u0000\u093b"+
		"\u0966\u0001\u0000\u0000\u0000\u093c\u093e\u0005\u0013\u0000\u0000\u093d"+
		"\u093f\u0005\u0081\u0000\u0000\u093e\u093d\u0001\u0000\u0000\u0000\u093e"+
		"\u093f\u0001\u0000\u0000\u0000\u093f\u0940\u0001\u0000\u0000\u0000\u0940"+
		"\u0941\u0005d\u0000\u0000\u0941\u0966\u0003\u010e\u0087\u0000\u0942\u0944"+
		"\u0005J\u0000\u0000\u0943\u0945\u0005\u0080\u0000\u0000\u0944\u0943\u0001"+
		"\u0000\u0000\u0000\u0944\u0945\u0001\u0000\u0000\u0000\u0945\u0947\u0001"+
		"\u0000\u0000\u0000\u0946\u0948\u0005\u0081\u0000\u0000\u0947\u0946\u0001"+
		"\u0000\u0000\u0000\u0947\u0948\u0001\u0000\u0000\u0000\u0948\u0966\u0001"+
		"\u0000\u0000\u0000\u0949\u094b\u0005J\u0000\u0000\u094a\u094c\u0005\u0081"+
		"\u0000\u0000\u094b\u094a\u0001\u0000\u0000\u0000\u094b\u094c\u0001\u0000"+
		"\u0000\u0000\u094c\u094d\u0001\u0000\u0000\u0000\u094d\u094e\u0005d\u0000"+
		"\u0000\u094e\u0966\u0003\u010e\u0087\u0000\u094f\u0950\u0005B\u0000\u0000"+
		"\u0950\u0951\u0005e\u0000\u0000\u0951\u0952\u0003\u0176\u00bb\u0000\u0952"+
		"\u0953\u0005f\u0000\u0000\u0953\u0955\u0005\u0013\u0000\u0000\u0954\u0956"+
		"\u0005\u0080\u0000\u0000\u0955\u0954\u0001\u0000\u0000\u0000\u0955\u0956"+
		"\u0001\u0000\u0000\u0000\u0956\u0958\u0001\u0000\u0000\u0000\u0957\u0959"+
		"\u0005\u0081\u0000\u0000\u0958\u0957\u0001\u0000\u0000\u0000\u0958\u0959"+
		"\u0001\u0000\u0000\u0000\u0959\u0966\u0001\u0000\u0000\u0000\u095a\u095b"+
		"\u0005B\u0000\u0000\u095b\u095c\u0005e\u0000\u0000\u095c\u095d\u0003\u0176"+
		"\u00bb\u0000\u095d\u095e\u0005f\u0000\u0000\u095e\u0960\u0005\u0013\u0000"+
		"\u0000\u095f\u0961\u0005\u0081\u0000\u0000\u0960\u095f\u0001\u0000\u0000"+
		"\u0000\u0960\u0961\u0001\u0000\u0000\u0000\u0961\u0962\u0001\u0000\u0000"+
		"\u0000\u0962\u0963\u0005d\u0000\u0000\u0963\u0964\u0003\u0004\u0002\u0000"+
		"\u0964\u0966\u0001\u0000\u0000\u0000\u0965\u0935\u0001\u0000\u0000\u0000"+
		"\u0965\u093c\u0001\u0000\u0000\u0000\u0965\u0942\u0001\u0000\u0000\u0000"+
		"\u0965\u0949\u0001\u0000\u0000\u0000\u0965\u094f\u0001\u0000\u0000\u0000"+
		"\u0965\u095a\u0001\u0000\u0000\u0000\u0966\u017b\u0001\u0000\u0000\u0000"+
		"\u0967\u0968\u0003\u0180\u00c0\u0000\u0968\u096a\u0005e\u0000\u0000\u0969"+
		"\u096b\u0003\u0182\u00c1\u0000\u096a\u0969\u0001\u0000\u0000\u0000\u096a"+
		"\u096b\u0001";
	private static final String _serializedATNSegment1 =
		"\u0000\u0000\u0000\u096b\u096c\u0001\u0000\u0000\u0000\u096c\u096d\u0005"+
		"f\u0000\u0000\u096d\u017d\u0001\u0000\u0000\u0000\u096e\u097e\u0003\u017c"+
		"\u00be\u0000\u096f\u0970\u0003\u0170\u00b8\u0000\u0970\u0972\u0005e\u0000"+
		"\u0000\u0971\u0973\u0003\u0182\u00c1\u0000\u0972\u0971\u0001\u0000\u0000"+
		"\u0000\u0972\u0973\u0001\u0000\u0000\u0000\u0973\u0974\u0001\u0000\u0000"+
		"\u0000\u0974\u0975\u0005f\u0000\u0000\u0975\u097e\u0001\u0000\u0000\u0000"+
		"\u0976\u0977\u0003\u0172\u00b9\u0000\u0977\u0979\u0005e\u0000\u0000\u0978"+
		"\u097a\u0003\u0182\u00c1\u0000\u0979\u0978\u0001\u0000\u0000\u0000\u0979"+
		"\u097a\u0001\u0000\u0000\u0000\u097a\u097b\u0001\u0000\u0000\u0000\u097b"+
		"\u097c\u0005f\u0000\u0000\u097c\u097e\u0001\u0000\u0000\u0000\u097d\u096e"+
		"\u0001\u0000\u0000\u0000\u097d\u096f\u0001\u0000\u0000\u0000\u097d\u0976"+
		"\u0001\u0000\u0000\u0000\u097e\u017f\u0001\u0000\u0000\u0000\u097f\u0980"+
		"\u0005\u0081\u0000\u0000\u0980\u0181\u0001\u0000\u0000\u0000\u0981\u0982"+
		"\u0006\u00c1\uffff\uffff\u0000\u0982\u0984\u0003\u0184\u00c2\u0000\u0983"+
		"\u0985\u0005\u0080\u0000\u0000\u0984\u0983\u0001\u0000\u0000\u0000\u0984"+
		"\u0985\u0001\u0000\u0000\u0000\u0985\u098e\u0001\u0000\u0000\u0000\u0986"+
		"\u0987\n\u0001\u0000\u0000\u0987\u0988\u0005w\u0000\u0000\u0988\u098a"+
		"\u0003\u0184\u00c2\u0000\u0989\u098b\u0005\u0080\u0000\u0000\u098a\u0989"+
		"\u0001\u0000\u0000\u0000\u098a\u098b\u0001\u0000\u0000\u0000\u098b\u098d"+
		"\u0001\u0000\u0000\u0000\u098c\u0986\u0001\u0000\u0000\u0000\u098d\u0990"+
		"\u0001\u0000\u0000\u0000\u098e\u098c\u0001\u0000\u0000\u0000\u098e\u098f"+
		"\u0001\u0000\u0000\u0000\u098f\u0183\u0001\u0000\u0000\u0000\u0990\u098e"+
		"\u0001\u0000\u0000\u0000\u0991\u0995\u0003\u010e\u0087\u0000\u0992\u0995"+
		"\u0003h4\u0000\u0993\u0995\u0003\u0004\u0002\u0000\u0994\u0991\u0001\u0000"+
		"\u0000\u0000\u0994\u0992\u0001\u0000\u0000\u0000\u0994\u0993\u0001\u0000"+
		"\u0000\u0000\u0995\u0185\u0001\u0000\u0000\u0000\u0996\u0997\u0005J\u0000"+
		"\u0000\u0997\u0998\u0003\n\u0005\u0000\u0998\u0999\u0005\u0081\u0000\u0000"+
		"\u0999\u09a2\u0001\u0000\u0000\u0000\u099a\u099b\u0005J\u0000\u0000\u099b"+
		"\u099d\u0003\n\u0005\u0000\u099c\u099e\u0005B\u0000\u0000\u099d\u099c"+
		"\u0001\u0000\u0000\u0000\u099d\u099e\u0001\u0000\u0000\u0000\u099e\u099f"+
		"\u0001\u0000\u0000\u0000\u099f\u09a0\u0003\u017c\u00be\u0000\u09a0\u09a2"+
		"\u0001\u0000\u0000\u0000\u09a1\u0996\u0001\u0000\u0000\u0000\u09a1\u099a"+
		"\u0001\u0000\u0000\u0000\u09a2\u0187\u0001\u0000\u0000\u0000\u09a3\u09a5"+
		"\u0005\"\u0000\u0000\u09a4\u09a3\u0001\u0000\u0000\u0000\u09a4\u09a5\u0001"+
		"\u0000\u0000\u0000\u09a5\u09a6\u0001\u0000\u0000\u0000\u09a6\u09a7\u0005"+
		"B\u0000\u0000\u09a7\u09a8\u0003\u0086C\u0000\u09a8\u0189\u0001\u0000\u0000"+
		"\u0000\u09a9\u09aa\u0005B\u0000\u0000\u09aa\u09ab\u0005e\u0000\u0000\u09ab"+
		"\u09ac\u0005f\u0000\u0000\u09ac\u09ad\u0003\u0086C\u0000\u09ad\u018b\u0001"+
		"\u0000\u0000\u0000\u09ae\u09af\u0005G\u0000\u0000\u09af\u09b0\u0003p8"+
		"\u0000\u09b0\u09b1\u0003\u0190\u00c8\u0000\u09b1\u018d\u0001\u0000\u0000"+
		"\u0000\u09b2\u09b4\u0005G\u0000\u0000\u09b3\u09b5\u0003\u0168\u00b4\u0000"+
		"\u09b4\u09b3\u0001\u0000\u0000\u0000\u09b4\u09b5\u0001\u0000\u0000\u0000"+
		"\u09b5\u09b6\u0001\u0000\u0000\u0000\u09b6\u09b7\u0003p8\u0000\u09b7\u09b8"+
		"\u0003\u0190\u00c8\u0000\u09b8\u018f\u0001\u0000\u0000\u0000\u09b9\u09bb"+
		"\u0003\u0192\u00c9\u0000\u09ba\u09bc\u0003\u0190\u00c8\u0000\u09bb\u09ba"+
		"\u0001\u0000\u0000\u0000\u09bb\u09bc\u0001\u0000\u0000\u0000\u09bc\u0191"+
		"\u0001\u0000\u0000\u0000\u09bd\u09be\u0005\u000f\u0000\u0000\u09be\u09bf"+
		"\u0005T\u0000\u0000\u09bf\u09c0\u0003\u0194\u00ca\u0000\u09c0\u09c1\u0005"+
		"U\u0000\u0000\u09c1\u09c2\u0003p8\u0000\u09c2\u0193\u0001\u0000\u0000"+
		"\u0000\u09c3\u09c5\u0003\u00e0p\u0000\u09c4\u09c3\u0001\u0000\u0000\u0000"+
		"\u09c4\u09c5\u0001\u0000\u0000\u0000\u09c5\u09c6\u0001\u0000\u0000\u0000"+
		"\u09c6\u09c7\u0003\u00a4R\u0000\u09c7\u09c8\u0003\u00fa}\u0000\u09c8\u09d2"+
		"\u0001\u0000\u0000\u0000\u09c9\u09cb\u0003\u00e0p\u0000\u09ca\u09c9\u0001"+
		"\u0000\u0000\u0000\u09ca\u09cb\u0001\u0000\u0000\u0000\u09cb\u09cc\u0001"+
		"\u0000\u0000\u0000\u09cc\u09ce\u0003\u00a4R\u0000\u09cd\u09cf\u0003\u0110"+
		"\u0088\u0000\u09ce\u09cd\u0001\u0000\u0000\u0000\u09ce\u09cf\u0001\u0000"+
		"\u0000\u0000\u09cf\u09d2\u0001\u0000\u0000\u0000\u09d0\u09d2\u0005\u0080"+
		"\u0000\u0000\u09d1\u09c4\u0001\u0000\u0000\u0000\u09d1\u09ca\u0001\u0000"+
		"\u0000\u0000\u09d1\u09d0\u0001\u0000\u0000\u0000\u09d2\u0195\u0001\u0000"+
		"\u0000\u0000\u09d3\u09d5\u0005E\u0000\u0000\u09d4\u09d6\u0003b1\u0000"+
		"\u09d5\u09d4\u0001\u0000\u0000\u0000\u09d5\u09d6\u0001\u0000\u0000\u0000"+
		"\u09d6\u0197\u0001\u0000\u0000\u0000\u09d7\u09da\u0003\u019a\u00cd\u0000"+
		"\u09d8\u09da\u0003\u019e\u00cf\u0000\u09d9\u09d7\u0001\u0000\u0000\u0000"+
		"\u09d9\u09d8\u0001\u0000\u0000\u0000\u09da\u0199\u0001\u0000\u0000\u0000"+
		"\u09db\u09dc\u0005E\u0000\u0000\u09dc\u09de\u0005T\u0000\u0000\u09dd\u09df"+
		"\u0003\u019c\u00ce\u0000\u09de\u09dd\u0001\u0000\u0000\u0000\u09de\u09df"+
		"\u0001\u0000\u0000\u0000\u09df\u09e0\u0001\u0000\u0000\u0000\u09e0\u09e1"+
		"\u0005U\u0000\u0000\u09e1\u019b\u0001\u0000\u0000\u0000\u09e2\u09e3\u0006"+
		"\u00ce\uffff\uffff\u0000\u09e3\u09e5\u0003\u010e\u0087\u0000\u09e4\u09e6"+
		"\u0005\u0080\u0000\u0000\u09e5\u09e4\u0001\u0000\u0000\u0000\u09e5\u09e6"+
		"\u0001\u0000\u0000\u0000\u09e6\u09ef\u0001\u0000\u0000\u0000\u09e7\u09e8"+
		"\n\u0001\u0000\u0000\u09e8\u09e9\u0005w\u0000\u0000\u09e9\u09eb\u0003"+
		"\u010e\u0087\u0000\u09ea\u09ec\u0005\u0080\u0000\u0000\u09eb\u09ea\u0001"+
		"\u0000\u0000\u0000\u09eb\u09ec\u0001\u0000\u0000\u0000\u09ec\u09ee\u0001"+
		"\u0000\u0000\u0000\u09ed\u09e7\u0001\u0000\u0000\u0000\u09ee\u09f1\u0001"+
		"\u0000\u0000\u0000\u09ef\u09ed\u0001\u0000\u0000\u0000\u09ef\u09f0\u0001"+
		"\u0000\u0000\u0000\u09f0\u019d\u0001\u0000\u0000\u0000\u09f1\u09ef\u0001"+
		"\u0000\u0000\u0000\u09f2\u09f3\u00050\u0000\u0000\u09f3\u09f4\u0005T\u0000"+
		"\u0000\u09f4\u09f5\u0003h4\u0000\u09f5\u09f6\u0005U\u0000\u0000\u09f6"+
		"\u09f9\u0001\u0000\u0000\u0000\u09f7\u09f9\u00050\u0000\u0000\u09f8\u09f2"+
		"\u0001\u0000\u0000\u0000\u09f8\u09f7\u0001\u0000\u0000\u0000\u09f9\u019f"+
		"\u0001\u0000\u0000\u0000\u09fa\u09fb\u0005e\u0000\u0000\u09fb\u09fc\u0005"+
		"e\u0000\u0000\u09fc\u01a1\u0001\u0000\u0000\u0000\u09fd\u09fe\u0005e\u0000"+
		"\u0000\u09fe\u09ff\u0005q\u0000\u0000\u09ff\u01a3\u0001\u0000\u0000\u0000"+
		"\u0a00\u0a01\u0005f\u0000\u0000\u0a01\u0a02\u0005f\u0000\u0000\u0a02\u01a5"+
		"\u0001\u0000\u0000\u0000\u0a03\u0a04\u0005f\u0000\u0000\u0a04\u0a05\u0005"+
		"r\u0000\u0000\u0a05\u01a7\u0001\u0000\u0000\u0000\u0a06\u0a3a\u0005/\u0000"+
		"\u0000\u0a07\u0a3a\u0005\u001a\u0000\u0000\u0a08\u0a09\u0005/\u0000\u0000"+
		"\u0a09\u0a0a\u0005V\u0000\u0000\u0a0a\u0a3a\u0005W\u0000\u0000\u0a0b\u0a0c"+
		"\u0005\u001a\u0000\u0000\u0a0c\u0a0d\u0005V\u0000\u0000\u0a0d\u0a3a\u0005"+
		"W\u0000\u0000\u0a0e\u0a3a\u0005Z\u0000\u0000\u0a0f\u0a3a\u0005[\u0000"+
		"\u0000\u0a10\u0a3a\u0005\\\u0000\u0000\u0a11\u0a3a\u0005]\u0000\u0000"+
		"\u0a12\u0a3a\u0005^\u0000\u0000\u0a13\u0a3a\u0005_\u0000\u0000\u0a14\u0a3a"+
		"\u0005`\u0000\u0000\u0a15\u0a3a\u0005a\u0000\u0000\u0a16\u0a3a\u0005b"+
		"\u0000\u0000\u0a17\u0a3a\u0005\u0001\u0000\u0000\u0a18\u0a3a\u0005\u0002"+
		"\u0000\u0000\u0a19\u0a3a\u0005d\u0000\u0000\u0a1a\u0a3a\u0005e\u0000\u0000"+
		"\u0a1b\u0a3a\u0005f\u0000\u0000\u0a1c\u0a3a\u0005g\u0000\u0000\u0a1d\u0a3a"+
		"\u0005h\u0000\u0000\u0a1e\u0a3a\u0005i\u0000\u0000\u0a1f\u0a3a\u0005j"+
		"\u0000\u0000\u0a20\u0a3a\u0005k\u0000\u0000\u0a21\u0a3a\u0005l\u0000\u0000"+
		"\u0a22\u0a3a\u0005m\u0000\u0000\u0a23\u0a3a\u0005n\u0000\u0000\u0a24\u0a3a"+
		"\u0003\u01a0\u00d0\u0000\u0a25\u0a3a\u0003\u01a4\u00d2\u0000\u0a26\u0a3a"+
		"\u0003\u01a6\u00d3\u0000\u0a27\u0a3a\u0003\u01a2\u00d1\u0000\u0a28\u0a3a"+
		"\u0005o\u0000\u0000\u0a29\u0a3a\u0005p\u0000\u0000\u0a2a\u0a3a\u0005q"+
		"\u0000\u0000\u0a2b\u0a3a\u0005r\u0000\u0000\u0a2c\u0a3a\u0005\u0004\u0000"+
		"\u0000\u0a2d\u0a3a\u0005\u0003\u0000\u0000\u0a2e\u0a3a\u0005\u0006\u0000"+
		"\u0000\u0a2f\u0a3a\u0005\u0005\u0000\u0000\u0a30\u0a3a\u0005u\u0000\u0000"+
		"\u0a31\u0a3a\u0005v\u0000\u0000\u0a32\u0a3a\u0005w\u0000\u0000\u0a33\u0a3a"+
		"\u0005x\u0000\u0000\u0a34\u0a3a\u0005y\u0000\u0000\u0a35\u0a36\u0005T"+
		"\u0000\u0000\u0a36\u0a3a\u0005U\u0000\u0000\u0a37\u0a38\u0005V\u0000\u0000"+
		"\u0a38\u0a3a\u0005W\u0000\u0000\u0a39\u0a06\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a07\u0001\u0000\u0000\u0000\u0a39\u0a08\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a0b\u0001\u0000\u0000\u0000\u0a39\u0a0e\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a0f\u0001\u0000\u0000\u0000\u0a39\u0a10\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a11\u0001\u0000\u0000\u0000\u0a39\u0a12\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a13\u0001\u0000\u0000\u0000\u0a39\u0a14\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a15\u0001\u0000\u0000\u0000\u0a39\u0a16\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a17\u0001\u0000\u0000\u0000\u0a39\u0a18\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a19\u0001\u0000\u0000\u0000\u0a39\u0a1a\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a1b\u0001\u0000\u0000\u0000\u0a39\u0a1c\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a1d\u0001\u0000\u0000\u0000\u0a39\u0a1e\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a1f\u0001\u0000\u0000\u0000\u0a39\u0a20\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a21\u0001\u0000\u0000\u0000\u0a39\u0a22\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a23\u0001\u0000\u0000\u0000\u0a39\u0a24\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a25\u0001\u0000\u0000\u0000\u0a39\u0a26\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a27\u0001\u0000\u0000\u0000\u0a39\u0a28\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a29\u0001\u0000\u0000\u0000\u0a39\u0a2a\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a2b\u0001\u0000\u0000\u0000\u0a39\u0a2c\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a2d\u0001\u0000\u0000\u0000\u0a39\u0a2e\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a2f\u0001\u0000\u0000\u0000\u0a39\u0a30\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a31\u0001\u0000\u0000\u0000\u0a39\u0a32\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a33\u0001\u0000\u0000\u0000\u0a39\u0a34\u0001\u0000\u0000\u0000\u0a39"+
		"\u0a35\u0001\u0000\u0000\u0000\u0a39\u0a37\u0001\u0000\u0000\u0000\u0a3a"+
		"\u01a9\u0001\u0000\u0000\u0000\u0a3b\u0a43\u0005\u0082\u0000\u0000\u0a3c"+
		"\u0a43\u0005\u0088\u0000\u0000\u0a3d\u0a43\u0005\u0089\u0000\u0000\u0a3e"+
		"\u0a43\u0003\u01ac\u00d6\u0000\u0a3f\u0a43\u0003\u01ae\u00d7\u0000\u0a40"+
		"\u0a43\u0003\u01b0\u00d8\u0000\u0a41\u0a43\u0003\u01b2\u00d9\u0000\u0a42"+
		"\u0a3b\u0001\u0000\u0000\u0000\u0a42\u0a3c\u0001\u0000\u0000\u0000\u0a42"+
		"\u0a3d\u0001\u0000\u0000\u0000\u0a42\u0a3e\u0001\u0000\u0000\u0000\u0a42"+
		"\u0a3f\u0001\u0000\u0000\u0000\u0a42\u0a40\u0001\u0000\u0000\u0000\u0a42"+
		"\u0a41\u0001\u0000\u0000\u0000\u0a43\u01ab\u0001\u0000\u0000\u0000\u0a44"+
		"\u0a45\u0006\u00d6\uffff\uffff\u0000\u0a45\u0a46\u0005\u008a\u0000\u0000"+
		"\u0a46\u0a4b\u0001\u0000\u0000\u0000\u0a47\u0a48\n\u0001\u0000\u0000\u0a48"+
		"\u0a4a\u0005\u008a\u0000\u0000\u0a49\u0a47\u0001\u0000\u0000\u0000\u0a4a"+
		"\u0a4d\u0001\u0000\u0000\u0000\u0a4b\u0a49\u0001\u0000\u0000\u0000\u0a4b"+
		"\u0a4c\u0001\u0000\u0000\u0000\u0a4c\u01ad\u0001\u0000\u0000\u0000\u0a4d"+
		"\u0a4b\u0001\u0000\u0000\u0000\u0a4e\u0a4f\u0007\t\u0000\u0000\u0a4f\u01af"+
		"\u0001\u0000\u0000\u0000\u0a50\u0a51\u00051\u0000\u0000\u0a51\u01b1\u0001"+
		"\u0000\u0000\u0000\u0a52\u0a53\u0007\n\u0000\u0000\u0a53\u01b3\u0001\u0000"+
		"\u0000\u0000\u0153\u01b5\u01c1\u01c5\u01d0\u01d4\u01e3\u01ea\u01ef\u01f1"+
		"\u01f6\u01fc\u0206\u020d\u0213\u0217\u021c\u0222\u0229\u022f\u0232\u0235"+
		"\u0238\u023f\u0246\u024c\u027b\u028a\u0290\u0296\u02a3\u02a5\u02af\u02be"+
		"\u02c4\u02e2\u02e7\u02eb\u02ef\u02f2\u02f6\u02fc\u02fe\u0306\u030a\u030d"+
		"\u0314\u031b\u031f\u0324\u0328\u032b\u0330\u0336\u0343\u034e\u0350\u035c"+
		"\u0365\u0367\u0373\u0375\u0382\u0384\u0390\u0398\u039c\u03aa\u03ac\u03b8"+
		"\u03ba\u03c5\u03d0\u03db\u03e8\u03ea\u03f9\u03fb\u0407\u040f\u041c\u0426"+
		"\u042d\u0431\u0435\u0439\u043d\u0442\u0446\u0449\u044f\u0457\u045c\u045f"+
		"\u0465\u0469\u0472\u0489\u048d\u0495\u049b\u04af\u04b3\u04c0\u04c4\u04c7"+
		"\u04ce\u04d6\u04e0\u04eb\u04f7\u0501\u0506\u050d\u0510\u0515\u051a\u052f"+
		"\u0533\u0538\u0548\u054e\u0552\u0557\u055b\u0560\u0563\u0566\u057d\u0583"+
		"\u058e\u0592\u0595\u059a\u05a2\u05a8\u05ab\u05b2\u05bc\u05c0\u05c3\u05c6"+
		"\u05ca\u05cf\u05d1\u05d5\u05d9\u05e2\u05ef\u05f7\u05fd\u0603\u0607\u060a"+
		"\u0613\u061c\u0624\u062f\u0635\u0640\u0643\u0648\u0657\u065d\u0666\u0670"+
		"\u0676\u067e\u0682\u0686\u068b\u0690\u0697\u0699\u069e\u06a2\u06b0\u06b6"+
		"\u06c8\u06ca\u06d4\u06d9\u06e0\u06e6\u06eb\u06f1\u06f8\u06fc\u06fe\u0700"+
		"\u0707\u070a\u070d\u0710\u0715\u0719\u071c\u0720\u0724\u0729\u072c\u072e"+
		"\u0732\u0739\u073f\u0743\u0749\u074e\u0750\u0756\u075a\u0760\u0767\u076b"+
		"\u076d\u076f\u0776\u0780\u0784\u0786\u0788\u078c\u078f\u0795\u079f\u07a3"+
		"\u07a6\u07ac\u07b4\u07b8\u07bb\u07bf\u07c4\u07c7\u07ca\u07ce\u07d3\u07dd"+
		"\u07e4\u07e9\u07ed\u07f2\u07f8\u07fc\u0802\u0808\u080c\u0811\u0815\u0819"+
		"\u081e\u0822\u0826\u082d\u0834\u083a\u083e\u0842\u0844\u0848\u084c\u0852"+
		"\u0856\u0859\u0862\u0868\u086d\u086f\u0872\u0875\u0878\u087b\u0884\u088e"+
		"\u0893\u0896\u089a\u089d\u08a0\u08a4\u08ad\u08bc\u08c2\u08c6\u08ca\u08ce"+
		"\u08d2\u08d6\u08da\u08de\u08e1\u08e5\u08f0\u08f4\u08fb\u08ff\u0904\u0909"+
		"\u0910\u0914\u091e\u092e\u0933\u0937\u093a\u093e\u0944\u0947\u094b\u0955"+
		"\u0958\u0960\u0965\u096a\u0972\u0979\u097d\u0984\u098a\u098e\u0994\u099d"+
		"\u09a1\u09a4\u09b4\u09bb\u09c4\u09ca\u09ce\u09d1\u09d5\u09d9\u09de\u09e5"+
		"\u09eb\u09ef\u09f8\u0a39\u0a42\u0a4b";
	public static final String _serializedATN = Utils.join(
		new String[] {
			_serializedATNSegment0,
			_serializedATNSegment1
		},
		""
	);
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}